From ce442d79674ce3a9a0eb494fa82542ef5c90af3b Mon Sep 17 00:00:00 2001 From: David Wengier Date: Tue, 14 Jan 2025 08:36:31 +1100 Subject: [PATCH 01/76] Don't crash on null encoding --- .../Core/Def/Implementation/AbstractEditorFactory.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs b/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs index c926dfaa69880..c0888cb0e04b6 100644 --- a/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs +++ b/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs @@ -6,6 +6,7 @@ using System.IO; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using System.Text; using System.Threading; using System.Threading.Tasks; using Microsoft.CodeAnalysis; @@ -371,7 +372,7 @@ private async Task FormatDocumentCreatedFromTemplateAsync(IVsHierarchy hierarchy IOUtilities.PerformIO(() => { - using var textWriter = new StreamWriter(filePath, append: false, encoding: formattedText.Encoding); + using var textWriter = new StreamWriter(filePath, append: false, encoding: formattedText.Encoding ?? Encoding.UTF8); // We pass null here for cancellation, since cancelling in the middle of the file write would leave the file corrupted formattedText.Write(textWriter, cancellationToken: CancellationToken.None); }); From ac187ef2e3fa2fedb1cc607f04b42d8a198e5205 Mon Sep 17 00:00:00 2001 From: David Wengier Date: Tue, 14 Jan 2025 13:13:08 +1100 Subject: [PATCH 02/76] Fix test --- .../New.IntegrationTests/CSharp/CSharpWinForms.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpWinForms.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpWinForms.cs index 0229383641503..d165adb26ceb4 100644 --- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpWinForms.cs +++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpWinForms.cs @@ -95,7 +95,7 @@ public async Task AddClickHandler() Assert.Contains(@"this.SomeButton.Click += new System.EventHandler(this.ExecuteWhenButtonClicked);", designerActualText); await TestServices.SolutionExplorer.OpenFileAsync(project, "Form1.cs", HangMitigatingCancellationToken); var codeFileActualText = await TestServices.Editor.GetTextAsync(HangMitigatingCancellationToken); - Assert.Contains(@" public partial class Form1: Form + Assert.Contains(@" public partial class Form1 : Form { public Form1() { From 674262122b3fb45fddee579e2f568e0d49e8ea81 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Sat, 11 Jan 2025 00:04:39 -0800 Subject: [PATCH 03/76] Enable extract class and extract interface in LSP --- .../Services/LspExtractClassOptionsService.cs | 44 +++++++++++++++ .../LspExtractInterfaceOptionsService.cs | 33 ++++++++++++ .../Handler/CodeActions/CodeActionHelpers.cs | 53 ++++++++++++++++--- 3 files changed, 123 insertions(+), 7 deletions(-) create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractClassOptionsService.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractInterfaceOptionsService.cs diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractClassOptionsService.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractClassOptionsService.cs new file mode 100644 index 0000000000000..5a297e8549fd2 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractClassOptionsService.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Collections.Immutable; +using System.Composition; +using Microsoft.CodeAnalysis.ExtractClass; +using Microsoft.CodeAnalysis.Formatting; +using Microsoft.CodeAnalysis.Host.Mef; +using Roslyn.Utilities; + +namespace Microsoft.CodeAnalysis.LanguageServer.Services; + +[ExportWorkspaceService(typeof(IExtractClassOptionsService)), Shared] +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed class LspExtractClassOptionsService() : IExtractClassOptionsService +{ + public ExtractClassOptions? GetExtractClassOptions( + Document document, + INamedTypeSymbol originalType, + ImmutableArray selectedMembers, + SyntaxFormattingOptions formattingOptions, + CancellationToken cancellationToken) + { + var symbolsToUse = selectedMembers.IsEmpty + ? originalType.GetMembers().Where(member => member switch + { + IMethodSymbol methodSymbol => methodSymbol.MethodKind == MethodKind.Ordinary, + IFieldSymbol fieldSymbol => !fieldSymbol.IsImplicitlyDeclared, + _ => member.Kind == SymbolKind.Property || member.Kind == SymbolKind.Event + }) + : selectedMembers; + + var memberAnalysisResults = symbolsToUse.Select(m => new ExtractClassMemberAnalysisResult(m, makeAbstract: false)).ToImmutableArray(); + const string name = "NewBaseType"; + var extension = document.Project.Language == LanguageNames.CSharp ? ".cs" : ".vb"; + return new( + name + extension, + name, + true, + memberAnalysisResults); + } +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractInterfaceOptionsService.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractInterfaceOptionsService.cs new file mode 100644 index 0000000000000..bdfe8b6031bc6 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Services/LspExtractInterfaceOptionsService.cs @@ -0,0 +1,33 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Composition; +using Microsoft.CodeAnalysis.ExtractInterface; +using Microsoft.CodeAnalysis.Host.Mef; + +namespace Microsoft.CodeAnalysis.LanguageServer.Services; + +[ExportWorkspaceService(typeof(IExtractInterfaceOptionsService)), Shared] +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed class LspExtractInterfaceOptionsService() : IExtractInterfaceOptionsService +{ + public ExtractInterfaceOptionsResult GetExtractInterfaceOptions( + Document document, + List extractableMembers, + string defaultInterfaceName, + List conflictingTypeNames, + string defaultNamespace, + string generatedNameTypeParameterSuffix, + CancellationToken cancellationToken) + { + var extension = document.Project.Language == LanguageNames.CSharp ? ".cs" : ".vb"; + return new( + isCancelled: false, + [.. extractableMembers], + defaultInterfaceName, + defaultInterfaceName + extension, + ExtractInterfaceOptionsResult.ExtractLocation.SameFile); + } +} diff --git a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs index 42a87764d251d..15be8030772f4 100644 --- a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs +++ b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs @@ -10,9 +10,15 @@ using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CodeRefactorings; +using Microsoft.CodeAnalysis.CodeRefactorings.ExtractMethod; +using Microsoft.CodeAnalysis.ExtractClass; +using Microsoft.CodeAnalysis.ExtractInterface; +using Microsoft.CodeAnalysis.InlineMethod; +using Microsoft.CodeAnalysis.InlineTemporary; using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Text; using Microsoft.CodeAnalysis.UnifiedSuggestions; +using Microsoft.CodeAnalysis.UnifiedSuggestions.UnifiedSuggestedActions; using Roslyn.LanguageServer.Protocol; using Roslyn.Utilities; using CodeAction = Microsoft.CodeAnalysis.CodeActions.CodeAction; @@ -60,7 +66,7 @@ internal static class CodeActionHelpers codeActions.Add(GenerateVSCodeAction( request, documentText, suggestedAction: suggestedAction, - codeActionKind: GetCodeActionKindFromSuggestedActionCategoryName(set.CategoryName!), + codeActionKind: GetCodeActionKindFromSuggestedActionCategoryName(set.CategoryName!, suggestedAction), setPriority: set.Priority, applicableRange: set.ApplicableToSpan.HasValue ? ProtocolConversions.TextSpanToRange(set.ApplicableToSpan.Value, documentText) : null, currentSetNumber: currentSetNumber, @@ -81,7 +87,7 @@ internal static class CodeActionHelpers codeActions.AddRange(GenerateCodeActions( request, suggestedAction, - GetCodeActionKindFromSuggestedActionCategoryName(set.CategoryName!))); + GetCodeActionKindFromSuggestedActionCategoryName(set.CategoryName!, suggestedAction))); } } } @@ -92,7 +98,9 @@ internal static class CodeActionHelpers private static bool IsCodeActionNotSupportedByLSP(IUnifiedSuggestedAction suggestedAction) // Filter out code actions with options since they'll show dialogs and we can't remote the UI and the options. - => suggestedAction.OriginalCodeAction is CodeActionWithOptions + => (suggestedAction.OriginalCodeAction is CodeActionWithOptions + && suggestedAction.OriginalCodeAction is not ExtractInterfaceCodeAction + && suggestedAction.OriginalCodeAction is not ExtractClassWithDialogCodeAction) // Skip code actions that requires non-document changes. We can't apply them in LSP currently. // https://github.com/dotnet/roslyn/issues/48698 || suggestedAction.OriginalCodeAction.Tags.Contains(CodeAction.RequiresNonDocumentChange); @@ -319,8 +327,7 @@ public static async Task> GetCodeActionsAsync( { foreach (var suggestedAction in set.Actions) { - // Filter out code actions with options since they'll show dialogs and we can't remote the UI and the options. - if (suggestedAction.OriginalCodeAction is CodeActionWithOptions) + if (IsCodeActionNotSupportedByLSP(suggestedAction)) { continue; } @@ -403,16 +410,48 @@ private static async ValueTask> GetAct return actionSets; } - private static CodeActionKind GetCodeActionKindFromSuggestedActionCategoryName(string categoryName) + private static CodeActionKind GetCodeActionKindFromSuggestedActionCategoryName(string categoryName, IUnifiedSuggestedAction suggestedAction) => categoryName switch { UnifiedPredefinedSuggestedActionCategoryNames.CodeFix => CodeActionKind.QuickFix, - UnifiedPredefinedSuggestedActionCategoryNames.Refactoring => CodeActionKind.Refactor, + UnifiedPredefinedSuggestedActionCategoryNames.Refactoring => GetRefactoringKind(suggestedAction), UnifiedPredefinedSuggestedActionCategoryNames.StyleFix => CodeActionKind.QuickFix, UnifiedPredefinedSuggestedActionCategoryNames.ErrorFix => CodeActionKind.QuickFix, _ => throw ExceptionUtilities.UnexpectedValue(categoryName) }; + private static CodeActionKind GetRefactoringKind(IUnifiedSuggestedAction suggestedAction) + { + if (suggestedAction is not ICodeRefactoringSuggestedAction refactoringAction) + return CodeActionKind.Refactor; + + if (refactoringAction.CodeRefactoringProvider is ExtractInterfaceCodeRefactoringProvider + or AbstractExtractClassRefactoringProvider + or ExtractMethodCodeRefactoringProvider) + return CodeActionKind.RefactorExtract; + + if (IsInstanceOfGenericType(typeof(AbstractInlineMethodRefactoringProvider<,,,>), refactoringAction.CodeRefactoringProvider) + || IsInstanceOfGenericType(typeof(AbstractInlineTemporaryCodeRefactoringProvider<,>), refactoringAction.CodeRefactoringProvider)) + return CodeActionKind.RefactorInline; + + return CodeActionKind.Refactor; + + static bool IsInstanceOfGenericType(Type genericType, object instance) + { + Type type = instance.GetType(); + while (type != null) + { + if (type.IsGenericType && + type.GetGenericTypeDefinition() == genericType) + { + return true; + } + type = type.BaseType; + } + return false; + } + } + private static LSP.VSInternalPriorityLevel? UnifiedSuggestedActionSetPriorityToPriorityLevel(CodeActionPriority priority) => priority switch { From 3db737b0e3d593891b2434ea6994c8bff73d9641 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Sat, 11 Jan 2025 00:05:02 -0800 Subject: [PATCH 04/76] Add tests --- ...deAnalysis.LanguageServer.UnitTests.csproj | 16 +- .../Services/ExtractRefactoringTests.cs | 100 ++++++++++ ...ctLanguageServerHostTests.TestLspServer.cs | 153 ++++++++++++++++ .../AbstractLanguageServerHostTests.cs | 173 +++++++++++------- .../Utilities/TestLspServerExtensions.cs | 45 +++++ .../HostWorkspace/OpenProjectsHandler.cs | 6 +- .../HostWorkspace/OpenSolutionHandler.cs | 4 +- .../HostWorkspace/ProjectDependencyHelper.cs | 3 +- .../ProjectInitializationHandler.cs | 2 +- .../Handler/CodeActions/CodeActionHelpers.cs | 2 + 10 files changed, 427 insertions(+), 77 deletions(-) create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj index d76aa319a94d6..d252020fa7104 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj @@ -17,20 +17,22 @@ - + + + + + - + + - - + + diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs new file mode 100644 index 0000000000000..138f6a649c33b --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs @@ -0,0 +1,100 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics.CodeAnalysis; +using Microsoft.CodeAnalysis; +using Roslyn.Test.Utilities; +using Xunit.Abstractions; +using LSP = Roslyn.LanguageServer.Protocol; + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests.Services; + +public class ExtractRefactoringTests(ITestOutputHelper testOutputHelper) : AbstractLanguageServerHostTests(testOutputHelper) +{ + [Theory] + [CombinatorialData] + public async Task TestExtractBaseClass(bool includeDevKitComponents) + { + var markup = + """ + class {|caret:A|} + { + public void M() + { + } + } + """; + var expected = + """ + internal class NewBaseType + { + public void M() + { + } + } + + class A : NewBaseType + { + } + """; + + await using var testLspServer = await CreateCSharpLanguageServerAsync(markup, includeDevKitComponents); + var caretLocation = testLspServer.GetLocations("caret").Single(); + + await TestCodeActionAsync(testLspServer, caretLocation, "Extract base class...", expected); + } + + [Theory] + [CombinatorialData] + public async Task TestExtractInterface(bool includeDevKitComponents) + { + var markup = + """ + class {|caret:A|} + { + public void M() + { + } + } + """; + var expected = + """ + interface IA + { + void M(); + } + + class A : IA + { + public void M() + { + } + } + """; + + await using var testLspServer = await CreateCSharpLanguageServerAsync(markup, includeDevKitComponents); + var caretLocation = testLspServer.GetLocations("caret").Single(); + + await TestCodeActionAsync(testLspServer, caretLocation, "Extract interface...", expected); + } + + private static async Task TestCodeActionAsync( + TestLspServer testLspServer, + LSP.Location caretLocation, + string codeActionTitle, + [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expected) + { + var codeActionResults = await testLspServer.RunGetCodeActionsAsync(CreateCodeActionParams(caretLocation)); + + var unresolvedCodeAction = Assert.Single(codeActionResults, codeAction => codeAction.Title == codeActionTitle); + + var resolvedCodeAction = await testLspServer.RunGetCodeActionResolveAsync(unresolvedCodeAction); + + testLspServer.ApplyWorkspaceEdit(resolvedCodeAction.Edit); + + var updatedCode = testLspServer.GetDocumentText(caretLocation.Uri); + + AssertEx.Equal(expected, updatedCode); + } +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs new file mode 100644 index 0000000000000..2563ebd0622af --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Collections.Immutable; +using Microsoft.CodeAnalysis.LanguageServer.LanguageServer; +using Microsoft.CodeAnalysis.Text; +using Microsoft.VisualStudio.Composition; +using Nerdbank.Streams; +using Roslyn.LanguageServer.Protocol; +using Roslyn.Utilities; +using StreamJsonRpc; +using LSP = Roslyn.LanguageServer.Protocol; + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +public partial class AbstractLanguageServerHostTests +{ + internal sealed class TestLspServer : IAsyncDisposable + { + private readonly Dictionary _documents; + private readonly Dictionary> _locations; + private readonly Task _languageServerHostCompletionTask; + private readonly JsonRpc _clientRpc; + + private ServerCapabilities? _serverCapabilities; + + internal static async Task CreateAsync( + ClientCapabilities clientCapabilities, + TestOutputLogger logger, + string cacheDirectory, + bool includeDevKitComponents = true, + string[]? extensionPaths = null, + Dictionary? documents = null, + Dictionary>? locations = null) + { + var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync( + logger.Factory, includeDevKitComponents, cacheDirectory, extensionPaths, out var serverConfiguration, out var assemblyLoader); + exportProvider.GetExportedValue().InitializeConfiguration(serverConfiguration); + + var testLspServer = new TestLspServer(exportProvider, logger, assemblyLoader, documents ?? [], locations ?? []); + var initializeResponse = await testLspServer.Initialize(clientCapabilities); + Assert.NotNull(initializeResponse?.Capabilities); + testLspServer._serverCapabilities = initializeResponse!.Capabilities; + + await testLspServer.Initialized(); + + return testLspServer; + } + + internal LanguageServerHost LanguageServerHost { get; } + public ExportProvider ExportProvider { get; } + + internal ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("Initialize has not been called"); + + private TestLspServer(ExportProvider exportProvider, TestOutputLogger logger, IAssemblyLoader assemblyLoader, Dictionary documents, Dictionary> locations) + { + _documents = documents; + _locations = locations; + + var typeRefResolver = new ExtensionTypeRefResolver(assemblyLoader, logger.Factory); + + var (clientStream, serverStream) = FullDuplexStream.CreatePair(); + LanguageServerHost = new LanguageServerHost(serverStream, serverStream, exportProvider, logger, typeRefResolver); + + var messageFormatter = RoslynLanguageServer.CreateJsonMessageFormatter(); + _clientRpc = new JsonRpc(new HeaderDelimitedMessageHandler(clientStream, clientStream, messageFormatter)) + { + AllowModificationWhileListening = true, + ExceptionStrategy = ExceptionProcessing.ISerializable, + }; + + _clientRpc.StartListening(); + + // This task completes when the server shuts down. We store it so that we can wait for completion + // when we dispose of the test server. + LanguageServerHost.Start(); + + _languageServerHostCompletionTask = LanguageServerHost.WaitForExitAsync(); + ExportProvider = exportProvider; + } + + public async Task ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class + { + var result = await _clientRpc.InvokeWithParameterObjectAsync(methodName, request, cancellationToken: cancellationToken); + return result; + } + + public Task ExecuteNotificationAsync(string methodName, RequestType request) where RequestType : class + { + return _clientRpc.NotifyWithParameterObjectAsync(methodName, request); + } + + public Task ExecuteNotification0Async(string methodName) + { + return _clientRpc.NotifyWithParameterObjectAsync(methodName); + } + + public void AddClientLocalRpcTarget(object target) + { + _clientRpc.AddLocalRpcTarget(target); + } + + public void AddClientLocalRpcTarget(string methodName, Delegate handler) + { + _clientRpc.AddLocalRpcMethod(methodName, handler); + } + + public void ApplyWorkspaceEdit(WorkspaceEdit? workspaceEdit) + { + Assert.NotNull(workspaceEdit); + + // We do not support applying the following edits + Assert.Null(workspaceEdit.Changes); + Assert.Null(workspaceEdit.ChangeAnnotations); + + // Currently we only support applying TextDocumentEdits + var textDocumentEdits = (TextDocumentEdit[]?)workspaceEdit.DocumentChanges?.Value; + Assert.NotNull(textDocumentEdits); + + foreach (var documentEdit in textDocumentEdits) + { + var uri = documentEdit.TextDocument.Uri; + var document = _documents[uri]; + + var changes = documentEdit.Edits + .Select(edit => edit.Value) + .Cast() + .SelectAsArray(edit => ProtocolConversions.TextEditToTextChange(edit, document)); + + var updatedDocument = document.WithChanges(changes); + _documents[uri] = updatedDocument; + } + } + + public string GetDocumentText(Uri uri) => _documents[uri].ToString(); + + public IList GetLocations(string locationName) => _locations[locationName]; + + public async ValueTask DisposeAsync() + { + await _clientRpc.InvokeAsync(Methods.ShutdownName); + await _clientRpc.NotifyAsync(Methods.ExitName); + + // The language server host task should complete once shutdown and exit are called. +#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks + await _languageServerHostCompletionTask; +#pragma warning restore VSTHRD003 // Avoid awaiting foreign Tasks + + _clientRpc.Dispose(); + } + } +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs index 209704c7f0593..84e1a7cf26d52 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs @@ -2,17 +2,21 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using Microsoft.CodeAnalysis.LanguageServer.LanguageServer; +using System.Collections.Immutable; +using System.Diagnostics.CodeAnalysis; +using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; using Microsoft.CodeAnalysis.Test.Utilities; -using Microsoft.VisualStudio.Composition; -using Nerdbank.Streams; +using Microsoft.CodeAnalysis.Testing; +using Microsoft.CodeAnalysis.Text; using Roslyn.LanguageServer.Protocol; -using StreamJsonRpc; +using Roslyn.Test.Utilities; +using Roslyn.Utilities; using Xunit.Abstractions; +using LSP = Roslyn.LanguageServer.Protocol; namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; -public abstract class AbstractLanguageServerHostTests : IDisposable +public abstract partial class AbstractLanguageServerHostTests : IDisposable { protected TestOutputLogger TestOutputLogger { get; } protected TempRoot TempRoot { get; } @@ -25,88 +29,127 @@ protected AbstractLanguageServerHostTests(ITestOutputHelper testOutputHelper) MefCacheDirectory = TempRoot.CreateDirectory(); } - protected Task CreateLanguageServerAsync(bool includeDevKitComponents = true) - { - return TestLspServer.CreateAsync(new ClientCapabilities(), TestOutputLogger, MefCacheDirectory.Path, includeDevKitComponents); - } - public void Dispose() { TempRoot.Dispose(); } - protected sealed class TestLspServer : IAsyncDisposable + private protected Task CreateLanguageServerAsync(bool includeDevKitComponents = true) { - private readonly Task _languageServerHostCompletionTask; - private readonly JsonRpc _clientRpc; + return TestLspServer.CreateAsync(new ClientCapabilities(), TestOutputLogger, MefCacheDirectory.Path, includeDevKitComponents); + } - private ServerCapabilities? _serverCapabilities; + private protected async Task CreateCSharpLanguageServerAsync( + [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markupCode, + bool includeDevKitComponents = true) + { + string code; + int? cursorPosition; + ImmutableDictionary> spans; + TestFileMarkupParser.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans); + + // Write project file + var projectDirectory = TempRoot.CreateDirectory(); + var projectPath = Path.Combine(projectDirectory.Path, "Project.csproj"); + await File.WriteAllTextAsync(projectPath, $""" + + + Library + net{Environment.Version.Major}.0 + + + """); + + // Write code file + var codePath = Path.Combine(projectDirectory.Path, "Code.cs"); + await File.WriteAllTextAsync(codePath, code); + +#pragma warning disable RS0030 // Do not use banned APIs + Uri codeUri = new(codePath); +#pragma warning restore RS0030 // Do not use banned APIs + var text = SourceText.From(code); + Dictionary files = new() { [codeUri] = text }; + var annotatedLocations = GetAnnotatedLocations(codeUri, text, spans); + + // Create server and open the project + var server = await TestLspServer.CreateAsync( + new ClientCapabilities(), + TestOutputLogger, + MefCacheDirectory.Path, + includeDevKitComponents, + documents: files, + locations: annotatedLocations); + + // Perform restore and mock up project restore client handler + ProcessUtilities.Run("dotnet", $"restore --project {projectPath}"); + server.AddClientLocalRpcTarget(ProjectDependencyHelper.ProjectNeedsRestoreName, new Action((projectFilePaths) => { })); + + // Listen for project initialization + var projectInitialized = new TaskCompletionSource(); + server.AddClientLocalRpcTarget(ProjectInitializationHandler.ProjectInitializationCompleteName, () => projectInitialized.SetResult()); + +#pragma warning disable RS0030 // Do not use banned APIs + await server.OpenProjectsAsync([new(projectPath)]); +#pragma warning restore RS0030 // Do not use banned APIs + + // Wait for initialization + await projectInitialized.Task; + + return server; + } - internal static async Task CreateAsync(ClientCapabilities clientCapabilities, TestOutputLogger logger, string cacheDirectory, bool includeDevKitComponents = true, string[]? extensionPaths = null) + private protected static Dictionary> GetAnnotatedLocations(Uri codeUri, SourceText text, ImmutableDictionary> spanMap) + { + var locations = new Dictionary>(); + foreach (var (name, spans) in spanMap) { - var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync( - logger.Factory, includeDevKitComponents, cacheDirectory, extensionPaths, out var _, out var assemblyLoader); - var testLspServer = new TestLspServer(exportProvider, logger, assemblyLoader); - var initializeResponse = await testLspServer.ExecuteRequestAsync(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None); - Assert.NotNull(initializeResponse?.Capabilities); - testLspServer._serverCapabilities = initializeResponse!.Capabilities; + var locationsForName = locations.GetValueOrDefault(name, []); + locationsForName.AddRange(spans.Select(span => ConvertTextSpanWithTextToLocation(span, text, codeUri))); - await testLspServer.ExecuteRequestAsync(Methods.InitializedName, new InitializedParams(), CancellationToken.None); - - return testLspServer; + // Linked files will return duplicate annotated Locations for each document that links to the same file. + // Since the test output only cares about the actual file, make sure we de-dupe before returning. + locations[name] = [.. locationsForName.Distinct()]; } - internal LanguageServerHost LanguageServerHost { get; } - public ExportProvider ExportProvider { get; } - - internal ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("Initialize has not been called"); + return locations; - private TestLspServer(ExportProvider exportProvider, TestOutputLogger logger, IAssemblyLoader assemblyLoader) + static LSP.Location ConvertTextSpanWithTextToLocation(TextSpan span, SourceText text, Uri documentUri) { - var typeRefResolver = new ExtensionTypeRefResolver(assemblyLoader, logger.Factory); - - var (clientStream, serverStream) = FullDuplexStream.CreatePair(); - LanguageServerHost = new LanguageServerHost(serverStream, serverStream, exportProvider, logger, typeRefResolver); - - var messageFormatter = RoslynLanguageServer.CreateJsonMessageFormatter(); - _clientRpc = new JsonRpc(new HeaderDelimitedMessageHandler(clientStream, clientStream, messageFormatter)) + var location = new LSP.Location { - AllowModificationWhileListening = true, - ExceptionStrategy = ExceptionProcessing.ISerializable, + Uri = documentUri, + Range = ProtocolConversions.TextSpanToRange(span, text), }; - _clientRpc.StartListening(); - - // This task completes when the server shuts down. We store it so that we can wait for completion - // when we dispose of the test server. - LanguageServerHost.Start(); - - _languageServerHostCompletionTask = LanguageServerHost.WaitForExitAsync(); - ExportProvider = exportProvider; + return location; } + } - public async Task ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class - { - var result = await _clientRpc.InvokeWithParameterObjectAsync(methodName, request, cancellationToken: cancellationToken); - return result; - } + private protected static TextDocumentIdentifier CreateTextDocumentIdentifier(Uri uri, ProjectId? projectContext = null) + { + var documentIdentifier = new VSTextDocumentIdentifier { Uri = uri }; - public void AddClientLocalRpcTarget(object target) + if (projectContext != null) { - _clientRpc.AddLocalRpcTarget(target); + documentIdentifier.ProjectContext = new VSProjectContext + { + Id = ProtocolConversions.ProjectIdToProjectContextId(projectContext), + Label = projectContext.DebugName!, + Kind = LSP.VSProjectKind.CSharp + }; } - public async ValueTask DisposeAsync() - { - await _clientRpc.InvokeAsync(Methods.ShutdownName); - await _clientRpc.NotifyAsync(Methods.ExitName); - - // The language server host task should complete once shutdown and exit are called. -#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks - await _languageServerHostCompletionTask; -#pragma warning restore VSTHRD003 // Avoid awaiting foreign Tasks - - _clientRpc.Dispose(); - } + return documentIdentifier; } + + private protected static CodeActionParams CreateCodeActionParams(LSP.Location location) + => new() + { + TextDocument = CreateTextDocumentIdentifier(location.Uri), + Range = location.Range, + Context = new CodeActionContext + { + // TODO - Code actions should respect context. + } + }; } diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs new file mode 100644 index 0000000000000..ac304ae173487 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; +using Roslyn.LanguageServer.Protocol; +using static Microsoft.CodeAnalysis.LanguageServer.UnitTests.AbstractLanguageServerHostTests; + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +internal static class TestLspServerExtensions +{ + public static async Task Initialized(this TestLspServer testLspServer) + { + await testLspServer.ExecuteRequestAsync(Methods.InitializedName, new InitializedParams(), CancellationToken.None); + } + + public static async Task Initialize(this TestLspServer testLspServer, ClientCapabilities clientCapabilities) + { + return await testLspServer.ExecuteRequestAsync(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None); + } + + public static async Task OpenProjectsAsync(this TestLspServer testLspServer, Uri[] projects) + { + await testLspServer.ExecuteNotificationAsync(OpenProjectHandler.OpenProjectName, new() { Projects = projects }); + } + + public static async Task RunGetCodeActionsAsync( + this TestLspServer testLspServer, + CodeActionParams codeActionParams) + { + var result = await testLspServer.ExecuteRequestAsync(Methods.TextDocumentCodeActionName, codeActionParams, CancellationToken.None); + Assert.NotNull(result); + return [.. result.Cast()]; + } + + public static async Task RunGetCodeActionResolveAsync( + this TestLspServer testLspServer, + VSInternalCodeAction unresolvedCodeAction) + { + var result = (VSInternalCodeAction?)await testLspServer.ExecuteRequestAsync(Methods.CodeActionResolveName, unresolvedCodeAction, CancellationToken.None); + Assert.NotNull(result); + return result; + } +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenProjectsHandler.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenProjectsHandler.cs index 615c0863e5239..82dfdc68f6ea6 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenProjectsHandler.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenProjectsHandler.cs @@ -12,9 +12,11 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; [ExportCSharpVisualBasicStatelessLspService(typeof(OpenProjectHandler)), Shared] -[Method("project/open")] +[Method(OpenProjectName)] internal class OpenProjectHandler : ILspServiceNotificationHandler { + internal const string OpenProjectName = "project/open"; + private readonly LanguageServerProjectSystem _projectSystem; [ImportingConstructor] @@ -32,7 +34,7 @@ Task INotificationHandler.HandleNotification return _projectSystem.OpenProjectsAsync(request.Projects.SelectAsArray(p => p.LocalPath)); } - private class NotificationParams + internal class NotificationParams { [JsonPropertyName("projects")] public required Uri[] Projects { get; set; } diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenSolutionHandler.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenSolutionHandler.cs index 198c329b2ad96..4719287a0d00e 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenSolutionHandler.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/OpenSolutionHandler.cs @@ -11,9 +11,11 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; [ExportCSharpVisualBasicStatelessLspService(typeof(OpenSolutionHandler)), Shared] -[Method("solution/open")] +[Method(OpenSolutionName)] internal class OpenSolutionHandler : ILspServiceNotificationHandler { + internal const string OpenSolutionName = "solution/open"; + private readonly LanguageServerProjectSystem _projectSystem; [ImportingConstructor] diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectDependencyHelper.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectDependencyHelper.cs index ac0659d8c0df4..e52224ce1e0aa 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectDependencyHelper.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectDependencyHelper.cs @@ -11,11 +11,12 @@ using NuGet.ProjectModel; using NuGet.Versioning; using Roslyn.Utilities; +using StreamJsonRpc; namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; internal static class ProjectDependencyHelper { - private const string ProjectNeedsRestoreName = "workspace/_roslyn_projectNeedsRestore"; + internal const string ProjectNeedsRestoreName = "workspace/_roslyn_projectNeedsRestore"; internal static bool NeedsRestore(ProjectFileInfo newProjectFileInfo, ProjectFileInfo? previousProjectFileInfo, ILogger logger) { diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectInitializationHandler.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectInitializationHandler.cs index 79194cbe099ad..2917f1fbc307c 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectInitializationHandler.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/ProjectInitializationHandler.cs @@ -19,7 +19,7 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; [Export, Shared] internal sealed class ProjectInitializationHandler : IDisposable { - private const string ProjectInitializationCompleteName = "workspace/projectInitializationComplete"; + internal const string ProjectInitializationCompleteName = "workspace/projectInitializationComplete"; private readonly IServiceBroker _serviceBroker; private readonly ServiceBrokerClient _serviceBrokerClient; diff --git a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs index 15be8030772f4..7c9d1c01d5952 100644 --- a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs +++ b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs @@ -98,6 +98,8 @@ internal static class CodeActionHelpers private static bool IsCodeActionNotSupportedByLSP(IUnifiedSuggestedAction suggestedAction) // Filter out code actions with options since they'll show dialogs and we can't remote the UI and the options. + // Exceptions are made for ExtractClass and ExtractInterface because we have OptionsServices which + // provide reasonable defaults without user interaction. => (suggestedAction.OriginalCodeAction is CodeActionWithOptions && suggestedAction.OriginalCodeAction is not ExtractInterfaceCodeAction && suggestedAction.OriginalCodeAction is not ExtractClassWithDialogCodeAction) From 4d5167ba2d79577cc5bf827d0d41efcdab4e3e23 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Sat, 11 Jan 2025 01:14:17 -0800 Subject: [PATCH 05/76] Fixup --- .../Protocol/Handler/CodeActions/CodeActionHelpers.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs index 7c9d1c01d5952..ad0c8d6f6fdbe 100644 --- a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs +++ b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs @@ -440,7 +440,7 @@ or AbstractExtractClassRefactoringProvider static bool IsInstanceOfGenericType(Type genericType, object instance) { - Type type = instance.GetType(); + Type? type = instance.GetType(); while (type != null) { if (type.IsGenericType && From 59a55dc5130772bbb9f2a5dec61025644b34921b Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Mon, 13 Jan 2025 22:11:55 -0800 Subject: [PATCH 06/76] Add Kind property to CodeRefactoringProvider --- ...actExtractMethodCodeRefactoringProvider.cs | 2 ++ ...AbstractExtractClassRefactoringProvider.cs | 2 ++ ...ExtractInterfaceCodeRefactoringProvider.cs | 2 ++ ...AbstractInlineMethodRefactoringProvider.cs | 2 ++ ...tInlineTemporaryCodeRefactoringProvider.cs | 2 ++ .../Handler/CodeActions/CodeActionHelpers.cs | 32 +++---------------- .../CodeRefactorings/CodeRefactoringKind.cs | 19 +++++++++++ .../CodeRefactoringProvider.cs | 8 +++-- 8 files changed, 39 insertions(+), 30 deletions(-) create mode 100644 src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringKind.cs diff --git a/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs index c6bac26aa5ebc..24ef70bf21c2a 100644 --- a/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs @@ -25,6 +25,8 @@ namespace Microsoft.CodeAnalysis.CodeRefactorings.ExtractMethod; [method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] internal sealed class ExtractMethodCodeRefactoringProvider() : CodeRefactoringProvider { + internal override CodeRefactoringKind Kind => CodeRefactoringKind.Extract; + public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { // Don't bother if there isn't a selection diff --git a/src/Features/Core/Portable/ExtractClass/AbstractExtractClassRefactoringProvider.cs b/src/Features/Core/Portable/ExtractClass/AbstractExtractClassRefactoringProvider.cs index 0e2c11c772cbc..e46b1bd216a06 100644 --- a/src/Features/Core/Portable/ExtractClass/AbstractExtractClassRefactoringProvider.cs +++ b/src/Features/Core/Portable/ExtractClass/AbstractExtractClassRefactoringProvider.cs @@ -22,6 +22,8 @@ internal abstract class AbstractExtractClassRefactoringProvider(IExtractClassOpt protected abstract Task> GetSelectedNodesAsync(CodeRefactoringContext context); protected abstract Task GetSelectedClassDeclarationAsync(CodeRefactoringContext context); + internal override CodeRefactoringKind Kind => CodeRefactoringKind.Extract; + public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { var solution = context.Document.Project.Solution; diff --git a/src/Features/Core/Portable/ExtractInterface/ExtractInterfaceCodeRefactoringProvider.cs b/src/Features/Core/Portable/ExtractInterface/ExtractInterfaceCodeRefactoringProvider.cs index b7b3ad772eefb..6e26e00292e5d 100644 --- a/src/Features/Core/Portable/ExtractInterface/ExtractInterfaceCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ExtractInterface/ExtractInterfaceCodeRefactoringProvider.cs @@ -23,6 +23,8 @@ public ExtractInterfaceCodeRefactoringProvider() { } + internal override CodeRefactoringKind Kind => CodeRefactoringKind.Extract; + public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { var (document, textSpan, cancellationToken) = context; diff --git a/src/Features/Core/Portable/InlineMethod/AbstractInlineMethodRefactoringProvider.cs b/src/Features/Core/Portable/InlineMethod/AbstractInlineMethodRefactoringProvider.cs index 1282a8c2fbf6b..f52cde2563edf 100644 --- a/src/Features/Core/Portable/InlineMethod/AbstractInlineMethodRefactoringProvider.cs +++ b/src/Features/Core/Portable/InlineMethod/AbstractInlineMethodRefactoringProvider.cs @@ -79,6 +79,8 @@ protected AbstractInlineMethodRefactoringProvider( _semanticFactsService = semanticFactsService; } + internal override CodeRefactoringKind Kind => CodeRefactoringKind.Inline; + public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { var (document, _, cancellationToken) = context; diff --git a/src/Features/Core/Portable/InlineTemporary/AbstractInlineTemporaryCodeRefactoringProvider.cs b/src/Features/Core/Portable/InlineTemporary/AbstractInlineTemporaryCodeRefactoringProvider.cs index 2250e38f475da..392c420cd88db 100644 --- a/src/Features/Core/Portable/InlineTemporary/AbstractInlineTemporaryCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InlineTemporary/AbstractInlineTemporaryCodeRefactoringProvider.cs @@ -19,6 +19,8 @@ internal abstract class AbstractInlineTemporaryCodeRefactoringProvider< where TIdentifierNameSyntax : SyntaxNode where TVariableDeclaratorSyntax : SyntaxNode { + internal override CodeRefactoringKind Kind => CodeRefactoringKind.Inline; + protected static async Task> GetReferenceLocationsAsync( Document document, TVariableDeclaratorSyntax variableDeclarator, diff --git a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs index ad0c8d6f6fdbe..b4b3f3da64465 100644 --- a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs +++ b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs @@ -10,11 +10,8 @@ using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CodeRefactorings; -using Microsoft.CodeAnalysis.CodeRefactorings.ExtractMethod; using Microsoft.CodeAnalysis.ExtractClass; using Microsoft.CodeAnalysis.ExtractInterface; -using Microsoft.CodeAnalysis.InlineMethod; -using Microsoft.CodeAnalysis.InlineTemporary; using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Text; using Microsoft.CodeAnalysis.UnifiedSuggestions; @@ -427,31 +424,12 @@ private static CodeActionKind GetRefactoringKind(IUnifiedSuggestedAction suggest if (suggestedAction is not ICodeRefactoringSuggestedAction refactoringAction) return CodeActionKind.Refactor; - if (refactoringAction.CodeRefactoringProvider is ExtractInterfaceCodeRefactoringProvider - or AbstractExtractClassRefactoringProvider - or ExtractMethodCodeRefactoringProvider) - return CodeActionKind.RefactorExtract; - - if (IsInstanceOfGenericType(typeof(AbstractInlineMethodRefactoringProvider<,,,>), refactoringAction.CodeRefactoringProvider) - || IsInstanceOfGenericType(typeof(AbstractInlineTemporaryCodeRefactoringProvider<,>), refactoringAction.CodeRefactoringProvider)) - return CodeActionKind.RefactorInline; - - return CodeActionKind.Refactor; - - static bool IsInstanceOfGenericType(Type genericType, object instance) + return refactoringAction.CodeRefactoringProvider.Kind switch { - Type? type = instance.GetType(); - while (type != null) - { - if (type.IsGenericType && - type.GetGenericTypeDefinition() == genericType) - { - return true; - } - type = type.BaseType; - } - return false; - } + CodeRefactoringKind.Extract => CodeActionKind.RefactorExtract, + CodeRefactoringKind.Inline => CodeActionKind.RefactorInline, + _ => CodeActionKind.Refactor, + }; } private static LSP.VSInternalPriorityLevel? UnifiedSuggestedActionSetPriorityToPriorityLevel(CodeActionPriority priority) diff --git a/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringKind.cs b/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringKind.cs new file mode 100644 index 0000000000000..d437bfb5b98ad --- /dev/null +++ b/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringKind.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.CodeAnalysis.CodeRefactorings; + +/// +/// Most refactorings will have the kind. This allows us to draw +/// attention to Extract and Inline refactorings. +/// +/// +/// When new values are added here we should account for them in the `CodeActionHelpers` class. +/// +internal enum CodeRefactoringKind +{ + Refactoring = 0, + Extract = 1, + Inline = 2, +} diff --git a/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringProvider.cs b/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringProvider.cs index 444d71115e7ce..9985293a1b365 100644 --- a/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringProvider.cs +++ b/src/Workspaces/Core/Portable/CodeRefactorings/CodeRefactoringProvider.cs @@ -27,12 +27,14 @@ public abstract class CodeRefactoringProvider /// registered by this code refactoring provider across the supported s. /// Return null if the provider doesn't support fix all operation. /// - /// - /// TODO: Make public, tracked with https://github.com/dotnet/roslyn/issues/60703 - /// internal virtual FixAllProvider? GetFixAllProvider() => null; + /// + /// Gets the indicating what kind of refactoring it is. + /// + internal virtual CodeRefactoringKind Kind => CodeRefactoringKind.Refactoring; + /// /// Computes the group this provider should be considered to run at. Legal values /// this can be must be between and . From 4085cc06820d75e441a4f831cf37cf6fc9a1ce62 Mon Sep 17 00:00:00 2001 From: Jason Malinowski Date: Tue, 14 Jan 2025 13:05:00 -0800 Subject: [PATCH 07/76] Ensure we deploy the build hosts in Roslyn.VisualStudio.Setup Without this, Microsoft.CodeAnalysis.Workspaces.MSBuild.dll itself is deployed, but will fail to work since it can't find any build hosts deployed alongside the DLL. Fixes https://github.com/dotnet/roslyn/issues/73854 --- src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj index fc7afbc3b8f0d..8e34c513a30e9 100644 --- a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj +++ b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj @@ -168,7 +168,8 @@ Workspaces.MSBuild - BuiltProjectOutputGroup;SatelliteDllsProjectOutputGroup + + BuiltProjectOutputGroup;SatelliteDllsProjectOutputGroup;ContentFilesProjectOutputGroup true TargetFramework=net472 BindingRedirect From eb77f89221b7926a51b5a5ae437d2da378ff425d Mon Sep 17 00:00:00 2001 From: David Barbet Date: Wed, 15 Jan 2025 15:56:31 -0800 Subject: [PATCH 08/76] Opt in MS.CA.LS.Protocol into using optprof training data --- .../Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj | 1 + 1 file changed, 1 insertion(+) diff --git a/src/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj b/src/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj index 73945f4ec700e..0f49abbd7a401 100644 --- a/src/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj +++ b/src/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj @@ -9,6 +9,7 @@ .NET Compiler Platform ("Roslyn") support for Language Server Protocol. + full From 550c6f832e5a4ca6b153edc5ec3a7f8d6c9043d5 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Wed, 15 Jan 2025 17:38:05 -0800 Subject: [PATCH 09/76] Change tests to launch the LanguageServer directly instead of hosting it. --- ...deAnalysis.LanguageServer.UnitTests.csproj | 17 +- .../Services/ExtractRefactoringTests.cs | 12 +- ...LanguageServerClientTests.TestLspClient.cs | 288 ++++++++++++++++++ .../AbstractLanguageServerClientTests.cs | 198 ++++++++++++ ...ctLanguageServerHostTests.TestLspServer.cs | 153 ---------- .../AbstractLanguageServerHostTests.cs | 186 +++++------ .../Utilities/ILspClient.cs | 16 + .../LanguageServerTestComposition.cs | 12 +- .../Utilities/LspClientExtensions.cs | 44 +++ .../Utilities/TestLspServerExtensions.cs | 45 --- .../Utilities/TestPaths.cs | 26 ++ ...crosoft.CodeAnalysis.LanguageServer.csproj | 10 + .../WindowsErrorReporting.cs | 10 +- 13 files changed, 690 insertions(+), 327 deletions(-) create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs delete mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/ILspClient.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LspClientExtensions.cs delete mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs create mode 100644 src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestPaths.cs diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj index d252020fa7104..4f65ae85bd18d 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj @@ -19,7 +19,7 @@ - + @@ -27,6 +27,21 @@ + + + + + + + + <_LanguageServerFile Include="$(_LanguageServerOutputPath)\**\*.*" /> + <_LanguageServerFile Remove="$(_LanguageServerOutputPath)\**\*.mef-composition" /> + + + + diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs index 138f6a649c33b..c913b9eca6a26 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs @@ -10,7 +10,7 @@ namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests.Services; -public class ExtractRefactoringTests(ITestOutputHelper testOutputHelper) : AbstractLanguageServerHostTests(testOutputHelper) +public class ExtractRefactoringTests(ITestOutputHelper testOutputHelper) : AbstractLanguageServerClientTests(testOutputHelper) { [Theory] [CombinatorialData] @@ -80,20 +80,20 @@ public void M() } private static async Task TestCodeActionAsync( - TestLspServer testLspServer, + TestLspClient testLspClient, LSP.Location caretLocation, string codeActionTitle, [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expected) { - var codeActionResults = await testLspServer.RunGetCodeActionsAsync(CreateCodeActionParams(caretLocation)); + var codeActionResults = await testLspClient.RunGetCodeActionsAsync(CreateCodeActionParams(caretLocation)); var unresolvedCodeAction = Assert.Single(codeActionResults, codeAction => codeAction.Title == codeActionTitle); - var resolvedCodeAction = await testLspServer.RunGetCodeActionResolveAsync(unresolvedCodeAction); + var resolvedCodeAction = await testLspClient.RunGetCodeActionResolveAsync(unresolvedCodeAction); - testLspServer.ApplyWorkspaceEdit(resolvedCodeAction.Edit); + testLspClient.ApplyWorkspaceEdit(resolvedCodeAction.Edit); - var updatedCode = testLspServer.GetDocumentText(caretLocation.Uri); + var updatedCode = testLspClient.GetDocumentText(caretLocation.Uri); AssertEx.Equal(expected, updatedCode); } diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs new file mode 100644 index 0000000000000..07c0fec996e34 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs @@ -0,0 +1,288 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Collections.Immutable; +using System.Diagnostics; +using System.IO.Pipes; +using System.Runtime.InteropServices; +using Microsoft.CodeAnalysis.Text; +using Microsoft.Extensions.Logging; +using Roslyn.LanguageServer.Protocol; +using Roslyn.Utilities; +using StreamJsonRpc; +using LSP = Roslyn.LanguageServer.Protocol; + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +public partial class AbstractLanguageServerClientTests +{ + internal sealed class TestLspClient : ILspClient, IAsyncDisposable + { + internal const int TimeOutMsNewProcess = 60_000; + + private int _disposed = 0; + + private readonly Process _process; + private readonly Dictionary _documents; + private readonly Dictionary> _locations; + private readonly TestOutputLogger _logger; + + private readonly JsonRpc _clientRpc; + + private ServerCapabilities? _serverCapabilities; + + internal static async Task CreateAsync( + ClientCapabilities clientCapabilities, + string extensionLogsPath, + bool includeDevKitComponents, + bool debugLsp, + TestOutputLogger logger, + Dictionary? documents = null, + Dictionary>? locations = null) + { + var pipeName = CreateNewPipeName(); + var processStartInfo = CreateLspStartInfo(pipeName, extensionLogsPath, includeDevKitComponents, debugLsp); + + var process = Process.Start(processStartInfo); + Assert.NotNull(process); + + var lspClient = new TestLspClient(process, pipeName, documents ?? [], locations ?? [], logger); + + // We've subscribed to Disconnected, but if the process crashed before that point we might have not seen it + if (process.HasExited) + { + throw new Exception($"LSP process exited immediately with {process.ExitCode}"); + } + + // Initialize the capabilities. + var initializeResponse = await lspClient.Initialize(clientCapabilities); + Assert.NotNull(initializeResponse?.Capabilities); + lspClient._serverCapabilities = initializeResponse!.Capabilities; + + await lspClient.Initialized(); + + return lspClient; + + static string CreateNewPipeName() + { + const string WINDOWS_DOTNET_PREFIX = @"\\.\"; + + // The pipe name constructed by some systems is very long (due to temp path). + // Shorten the unique id for the pipe. + var newGuid = Guid.NewGuid().ToString(); + var pipeName = newGuid.Split('-')[0]; + + return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + ? WINDOWS_DOTNET_PREFIX + pipeName + : Path.Combine(Path.GetTempPath(), pipeName + ".sock"); + } + + static ProcessStartInfo CreateLspStartInfo(string pipeName, string extensionLogsPath, bool includeDevKitComponents, bool debugLsp) + { + var processStartInfo = new ProcessStartInfo() + { + FileName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet", + }; + + // We need to roll forward to the latest runtime, since the tests may be using a runtime newer than we ourselves built with. + // We set the environment variable since --roll-forward LatestMajor doesn't roll forward to prerelease runtimes otherwise. + processStartInfo.Environment["DOTNET_ROLL_FORWARD_TO_PRERELEASE"] = "1"; + processStartInfo.ArgumentList.Add("--roll-forward"); + processStartInfo.ArgumentList.Add("LatestMajor"); + + processStartInfo.ArgumentList.Add(TestPaths.GetLanguageServerPath()); + + processStartInfo.ArgumentList.Add("--pipe"); + processStartInfo.ArgumentList.Add(pipeName); + + processStartInfo.ArgumentList.Add("--logLevel"); + processStartInfo.ArgumentList.Add("Trace"); + + processStartInfo.ArgumentList.Add("--extensionLogDirectory"); + processStartInfo.ArgumentList.Add(extensionLogsPath); + + if (includeDevKitComponents) + { + processStartInfo.ArgumentList.Add("--devKitDependencyPath"); + processStartInfo.ArgumentList.Add(TestPaths.GetDevKitExtensionPath()); + } + + if (debugLsp) + { + processStartInfo.ArgumentList.Add("--debug"); + } + + processStartInfo.CreateNoWindow = false; + processStartInfo.UseShellExecute = false; + processStartInfo.RedirectStandardInput = true; + processStartInfo.RedirectStandardOutput = true; + processStartInfo.RedirectStandardError = true; + + return processStartInfo; + } + } + + internal ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("Initialize has not been called"); + + private TestLspClient(Process process, string pipeName, Dictionary documents, Dictionary> locations, TestOutputLogger logger) + { + _documents = documents; + _locations = locations; + _logger = logger; + _process = process; + + _process.EnableRaisingEvents = true; + _process.Exited += Process_Exited; + _process.OutputDataReceived += Process_OutputDataReceived; + _process.ErrorDataReceived += Process_ErrorDataReceived; + + // Call this last so our type is fully constructed before we start firing events + _process.BeginOutputReadLine(); + _process.BeginErrorReadLine(); + + Assert.False(_process.HasExited); + + var pipeClient = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly); + pipeClient.Connect(TimeOutMsNewProcess); + + var messageFormatter = RoslynLanguageServer.CreateJsonMessageFormatter(); + _clientRpc = new JsonRpc(new HeaderDelimitedMessageHandler(pipeClient, pipeClient, messageFormatter)) + { + AllowModificationWhileListening = true, + ExceptionStrategy = ExceptionProcessing.ISerializable, + }; + + _clientRpc.AddLocalRpcMethod(Methods.WindowLogMessageName, GetMessageLogger("LogMessage")); + _clientRpc.AddLocalRpcMethod(Methods.WindowShowMessageName, GetMessageLogger("ShowMessage")); + + _clientRpc.StartListening(); + + return; + + Action GetMessageLogger(string method) + { + return (int type, string message) => + { + var logLevel = (MessageType)type switch + { + MessageType.Error => LogLevel.Error, + MessageType.Warning => LogLevel.Warning, + MessageType.Info => LogLevel.Information, + MessageType.Log => LogLevel.Trace, + MessageType.Debug => LogLevel.Debug, + _ => LogLevel.Trace, + }; + _logger.Log(logLevel, "[LSP {Method}] {Message}", method, message); + }; + } + } + + private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e) + { + _logger.LogInformation("[LSP STDOUT] {Data}", e.Data); + } + + private void Process_ErrorDataReceived(object sender, DataReceivedEventArgs e) + { + _logger.LogCritical("[LSP STDERR] {Data}", e.Data); + } + + private void Process_Exited(object? sender, EventArgs e) + { + Disconnected?.Invoke(this, EventArgs.Empty); + } + + public event EventHandler? Disconnected; + + public async Task ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class + { + var result = await _clientRpc.InvokeWithParameterObjectAsync(methodName, request, cancellationToken); + return result; + } + + public Task ExecuteNotificationAsync(string methodName, RequestType request) where RequestType : class + { + return _clientRpc.NotifyWithParameterObjectAsync(methodName, request); + } + + public Task ExecuteNotification0Async(string methodName) + { + return _clientRpc.NotifyWithParameterObjectAsync(methodName); + } + + public void AddClientLocalRpcTarget(object target) + { + _clientRpc.AddLocalRpcTarget(target); + } + + public void AddClientLocalRpcTarget(string methodName, Delegate handler) + { + _clientRpc.AddLocalRpcMethod(methodName, handler); + } + + public void ApplyWorkspaceEdit(WorkspaceEdit? workspaceEdit) + { + Assert.NotNull(workspaceEdit); + + // We do not support applying the following edits + Assert.Null(workspaceEdit.Changes); + Assert.Null(workspaceEdit.ChangeAnnotations); + + // Currently we only support applying TextDocumentEdits + var textDocumentEdits = (TextDocumentEdit[]?)workspaceEdit.DocumentChanges?.Value; + Assert.NotNull(textDocumentEdits); + + foreach (var documentEdit in textDocumentEdits) + { + var uri = documentEdit.TextDocument.Uri; + var document = _documents[uri]; + + var changes = documentEdit.Edits + .Select(edit => edit.Value) + .Cast() + .SelectAsArray(edit => ProtocolConversions.TextEditToTextChange(edit, document)); + + var updatedDocument = document.WithChanges(changes); + _documents[uri] = updatedDocument; + } + } + + public string GetDocumentText(Uri uri) => _documents[uri].ToString(); + + public IList GetLocations(string locationName) => _locations[locationName]; + + public async ValueTask DisposeAsync() + { + // Ensure only one thing disposes; while we disconnect the process will go away, which will call us to do this again + if (Interlocked.CompareExchange(ref _disposed, value: 1, comparand: 0) != 0) + return; + + // We will call Shutdown in a try/catch; if the process has gone bad it's possible the connection is no longer functioning. + try + { + if (!_process.HasExited) + { + _logger.LogTrace("Sending a Shutdown request to the LSP."); + + await _clientRpc.InvokeAsync(Methods.ShutdownName); + await _clientRpc.NotifyAsync(Methods.ExitName); + } + + await _clientRpc.Completion; + + _clientRpc.Dispose(); + _process.Dispose(); + + _logger.LogTrace("Process shut down."); + } + catch (Exception e) + { + _logger.LogError(e, "Exception while shutting down the LSP process."); + + // Process may have gone bad, so not much else we can do. + _process.Kill(); + } + } + } +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs new file mode 100644 index 0000000000000..7e95ea26647a4 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs @@ -0,0 +1,198 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Collections.Immutable; +using System.Diagnostics.CodeAnalysis; +using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; +using Microsoft.CodeAnalysis.Test.Utilities; +using Microsoft.CodeAnalysis.Testing; +using Microsoft.CodeAnalysis.Text; +using Roslyn.LanguageServer.Protocol; +using Roslyn.Test.Utilities; +using Roslyn.Utilities; +using Xunit.Abstractions; +using LSP = Roslyn.LanguageServer.Protocol; + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +public abstract partial class AbstractLanguageServerClientTests(ITestOutputHelper testOutputHelper) : IAsyncLifetime +{ + private readonly SemaphoreSlim _gate = new(initialCount: 1); + private readonly List _lspClients = []; + + protected TestOutputLogger TestOutputLogger => new(testOutputHelper); + protected TempRoot TempRoot => new(); + protected TempDirectory ExtensionLogsDirectory => TempRoot.CreateDirectory(); + + public Task InitializeAsync() + { + return Task.CompletedTask; + } + + public async Task DisposeAsync() + { + TempRoot.Dispose(); + + List clientsToDispose; + + // Copy the list out while we're in the lock, otherwise as we dispose these events will get fired, which + // may try to mutate the list while we're enumerating. + using (await _gate.DisposableWaitAsync().ConfigureAwait(false)) + { + clientsToDispose = [.. _lspClients]; + _lspClients.Clear(); + } + + foreach (var client in clientsToDispose) + await client.DisposeAsync().ConfigureAwait(false); + } + + private protected async Task CreateCSharpLanguageServerAsync( + [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markupCode, + bool includeDevKitComponents, + bool debugLsp = false) + { + string code; + int? cursorPosition; + ImmutableDictionary> spans; + TestFileMarkupParser.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans); + + // Write project file + var projectDirectory = TempRoot.CreateDirectory(); + var projectPath = Path.Combine(projectDirectory.Path, "Project.csproj"); + await File.WriteAllTextAsync(projectPath, $""" + + + Library + net{Environment.Version.Major}.0 + + + """); + + // Write code file + var codePath = Path.Combine(projectDirectory.Path, "Code.cs"); + await File.WriteAllTextAsync(codePath, code); + +#pragma warning disable RS0030 // Do not use banned APIs + Uri codeUri = new(codePath); +#pragma warning restore RS0030 // Do not use banned APIs + var text = SourceText.From(code); + Dictionary files = new() { [codeUri] = text }; + var annotatedLocations = GetAnnotatedLocations(codeUri, text, spans); + + TestLspClient? lspClient; + using (await _gate.DisposableWaitAsync().ConfigureAwait(false)) + { + // Create server and open the project + lspClient = await TestLspClient.CreateAsync( + new ClientCapabilities(), + ExtensionLogsDirectory.Path, + includeDevKitComponents, + debugLsp, + TestOutputLogger, + documents: files, + locations: annotatedLocations); + lspClient.Disconnected += LSP_Disconnected; + _lspClients.Add(lspClient); + } + + // Perform restore and mock up project restore client handler + ProcessUtilities.Run("dotnet", $"restore --project {projectPath}"); + lspClient.AddClientLocalRpcTarget(ProjectDependencyHelper.ProjectNeedsRestoreName, (string[] projectFilePaths) => { }); + + // Listen for project initialization + var projectInitialized = new TaskCompletionSource(); + lspClient.AddClientLocalRpcTarget(ProjectInitializationHandler.ProjectInitializationCompleteName, () => projectInitialized.SetResult()); + +#pragma warning disable RS0030 // Do not use banned APIs + await lspClient.OpenProjectsAsync([new(projectPath)]); +#pragma warning restore RS0030 // Do not use banned APIs + + // Wait for initialization + await projectInitialized.Task; + + return lspClient; + } + + private void LSP_Disconnected(object? sender, EventArgs e) + { + Contract.ThrowIfNull(sender, $"{nameof(TestLspClient)}.{nameof(TestLspClient.Disconnected)} was raised with a null sender."); + + Task.Run(async () => + { + TestLspClient? clientToDispose = null; + + using (await _gate.DisposableWaitAsync().ConfigureAwait(false)) + { + // Remove it from our map; it's possible it might have already been removed if we had more than one way we observed a disconnect. + clientToDispose = _lspClients.FirstOrDefault(c => c == sender); + if (clientToDispose is not null) + { + _lspClients.Remove(clientToDispose); + } + } + + // Dispose outside of the lock (even though we don't expect much to happen at this point) + if (clientToDispose is not null) + { + await clientToDispose.DisposeAsync().ConfigureAwait(false); + } + }); + } + + private protected static Dictionary> GetAnnotatedLocations(Uri codeUri, SourceText text, ImmutableDictionary> spanMap) + { + var locations = new Dictionary>(); + foreach (var (name, spans) in spanMap) + { + var locationsForName = locations.GetValueOrDefault(name, []); + locationsForName.AddRange(spans.Select(span => ConvertTextSpanWithTextToLocation(span, text, codeUri))); + + // Linked files will return duplicate annotated Locations for each document that links to the same file. + // Since the test output only cares about the actual file, make sure we de-dupe before returning. + locations[name] = [.. locationsForName.Distinct()]; + } + + return locations; + + static LSP.Location ConvertTextSpanWithTextToLocation(TextSpan span, SourceText text, Uri documentUri) + { + var location = new LSP.Location + { + Uri = documentUri, + Range = ProtocolConversions.TextSpanToRange(span, text), + }; + + return location; + } + } + + private protected static TextDocumentIdentifier CreateTextDocumentIdentifier(Uri uri, ProjectId? projectContext = null) + { + var documentIdentifier = new VSTextDocumentIdentifier { Uri = uri }; + + if (projectContext != null) + { + documentIdentifier.ProjectContext = new VSProjectContext + { + Id = ProtocolConversions.ProjectIdToProjectContextId(projectContext), + Label = projectContext.DebugName!, + Kind = VSProjectKind.CSharp + }; + } + + return documentIdentifier; + } + + private protected static CodeActionParams CreateCodeActionParams(LSP.Location location) + => new() + { + TextDocument = CreateTextDocumentIdentifier(location.Uri), + Range = location.Range, + Context = new CodeActionContext + { + // TODO - Code actions should respect context. + } + }; +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs deleted file mode 100644 index 2563ebd0622af..0000000000000 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.TestLspServer.cs +++ /dev/null @@ -1,153 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -using System.Collections.Immutable; -using Microsoft.CodeAnalysis.LanguageServer.LanguageServer; -using Microsoft.CodeAnalysis.Text; -using Microsoft.VisualStudio.Composition; -using Nerdbank.Streams; -using Roslyn.LanguageServer.Protocol; -using Roslyn.Utilities; -using StreamJsonRpc; -using LSP = Roslyn.LanguageServer.Protocol; - -namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; - -public partial class AbstractLanguageServerHostTests -{ - internal sealed class TestLspServer : IAsyncDisposable - { - private readonly Dictionary _documents; - private readonly Dictionary> _locations; - private readonly Task _languageServerHostCompletionTask; - private readonly JsonRpc _clientRpc; - - private ServerCapabilities? _serverCapabilities; - - internal static async Task CreateAsync( - ClientCapabilities clientCapabilities, - TestOutputLogger logger, - string cacheDirectory, - bool includeDevKitComponents = true, - string[]? extensionPaths = null, - Dictionary? documents = null, - Dictionary>? locations = null) - { - var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync( - logger.Factory, includeDevKitComponents, cacheDirectory, extensionPaths, out var serverConfiguration, out var assemblyLoader); - exportProvider.GetExportedValue().InitializeConfiguration(serverConfiguration); - - var testLspServer = new TestLspServer(exportProvider, logger, assemblyLoader, documents ?? [], locations ?? []); - var initializeResponse = await testLspServer.Initialize(clientCapabilities); - Assert.NotNull(initializeResponse?.Capabilities); - testLspServer._serverCapabilities = initializeResponse!.Capabilities; - - await testLspServer.Initialized(); - - return testLspServer; - } - - internal LanguageServerHost LanguageServerHost { get; } - public ExportProvider ExportProvider { get; } - - internal ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("Initialize has not been called"); - - private TestLspServer(ExportProvider exportProvider, TestOutputLogger logger, IAssemblyLoader assemblyLoader, Dictionary documents, Dictionary> locations) - { - _documents = documents; - _locations = locations; - - var typeRefResolver = new ExtensionTypeRefResolver(assemblyLoader, logger.Factory); - - var (clientStream, serverStream) = FullDuplexStream.CreatePair(); - LanguageServerHost = new LanguageServerHost(serverStream, serverStream, exportProvider, logger, typeRefResolver); - - var messageFormatter = RoslynLanguageServer.CreateJsonMessageFormatter(); - _clientRpc = new JsonRpc(new HeaderDelimitedMessageHandler(clientStream, clientStream, messageFormatter)) - { - AllowModificationWhileListening = true, - ExceptionStrategy = ExceptionProcessing.ISerializable, - }; - - _clientRpc.StartListening(); - - // This task completes when the server shuts down. We store it so that we can wait for completion - // when we dispose of the test server. - LanguageServerHost.Start(); - - _languageServerHostCompletionTask = LanguageServerHost.WaitForExitAsync(); - ExportProvider = exportProvider; - } - - public async Task ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class - { - var result = await _clientRpc.InvokeWithParameterObjectAsync(methodName, request, cancellationToken: cancellationToken); - return result; - } - - public Task ExecuteNotificationAsync(string methodName, RequestType request) where RequestType : class - { - return _clientRpc.NotifyWithParameterObjectAsync(methodName, request); - } - - public Task ExecuteNotification0Async(string methodName) - { - return _clientRpc.NotifyWithParameterObjectAsync(methodName); - } - - public void AddClientLocalRpcTarget(object target) - { - _clientRpc.AddLocalRpcTarget(target); - } - - public void AddClientLocalRpcTarget(string methodName, Delegate handler) - { - _clientRpc.AddLocalRpcMethod(methodName, handler); - } - - public void ApplyWorkspaceEdit(WorkspaceEdit? workspaceEdit) - { - Assert.NotNull(workspaceEdit); - - // We do not support applying the following edits - Assert.Null(workspaceEdit.Changes); - Assert.Null(workspaceEdit.ChangeAnnotations); - - // Currently we only support applying TextDocumentEdits - var textDocumentEdits = (TextDocumentEdit[]?)workspaceEdit.DocumentChanges?.Value; - Assert.NotNull(textDocumentEdits); - - foreach (var documentEdit in textDocumentEdits) - { - var uri = documentEdit.TextDocument.Uri; - var document = _documents[uri]; - - var changes = documentEdit.Edits - .Select(edit => edit.Value) - .Cast() - .SelectAsArray(edit => ProtocolConversions.TextEditToTextChange(edit, document)); - - var updatedDocument = document.WithChanges(changes); - _documents[uri] = updatedDocument; - } - } - - public string GetDocumentText(Uri uri) => _documents[uri].ToString(); - - public IList GetLocations(string locationName) => _locations[locationName]; - - public async ValueTask DisposeAsync() - { - await _clientRpc.InvokeAsync(Methods.ShutdownName); - await _clientRpc.NotifyAsync(Methods.ExitName); - - // The language server host task should complete once shutdown and exit are called. -#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks - await _languageServerHostCompletionTask; -#pragma warning restore VSTHRD003 // Avoid awaiting foreign Tasks - - _clientRpc.Dispose(); - } - } -} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs index 84e1a7cf26d52..b543d17c01d00 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs @@ -2,21 +2,17 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using System.Collections.Immutable; -using System.Diagnostics.CodeAnalysis; -using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; +using Microsoft.CodeAnalysis.LanguageServer.LanguageServer; using Microsoft.CodeAnalysis.Test.Utilities; -using Microsoft.CodeAnalysis.Testing; -using Microsoft.CodeAnalysis.Text; +using Microsoft.VisualStudio.Composition; +using Nerdbank.Streams; using Roslyn.LanguageServer.Protocol; -using Roslyn.Test.Utilities; -using Roslyn.Utilities; +using StreamJsonRpc; using Xunit.Abstractions; -using LSP = Roslyn.LanguageServer.Protocol; namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; -public abstract partial class AbstractLanguageServerHostTests : IDisposable +public abstract class AbstractLanguageServerHostTests : IDisposable { protected TestOutputLogger TestOutputLogger { get; } protected TempRoot TempRoot { get; } @@ -29,127 +25,103 @@ protected AbstractLanguageServerHostTests(ITestOutputHelper testOutputHelper) MefCacheDirectory = TempRoot.CreateDirectory(); } - public void Dispose() - { - TempRoot.Dispose(); - } - - private protected Task CreateLanguageServerAsync(bool includeDevKitComponents = true) + protected Task CreateLanguageServerAsync(bool includeDevKitComponents = true) { return TestLspServer.CreateAsync(new ClientCapabilities(), TestOutputLogger, MefCacheDirectory.Path, includeDevKitComponents); } - private protected async Task CreateCSharpLanguageServerAsync( - [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markupCode, - bool includeDevKitComponents = true) + public void Dispose() { - string code; - int? cursorPosition; - ImmutableDictionary> spans; - TestFileMarkupParser.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans); - - // Write project file - var projectDirectory = TempRoot.CreateDirectory(); - var projectPath = Path.Combine(projectDirectory.Path, "Project.csproj"); - await File.WriteAllTextAsync(projectPath, $""" - - - Library - net{Environment.Version.Major}.0 - - - """); - - // Write code file - var codePath = Path.Combine(projectDirectory.Path, "Code.cs"); - await File.WriteAllTextAsync(codePath, code); - -#pragma warning disable RS0030 // Do not use banned APIs - Uri codeUri = new(codePath); -#pragma warning restore RS0030 // Do not use banned APIs - var text = SourceText.From(code); - Dictionary files = new() { [codeUri] = text }; - var annotatedLocations = GetAnnotatedLocations(codeUri, text, spans); - - // Create server and open the project - var server = await TestLspServer.CreateAsync( - new ClientCapabilities(), - TestOutputLogger, - MefCacheDirectory.Path, - includeDevKitComponents, - documents: files, - locations: annotatedLocations); - - // Perform restore and mock up project restore client handler - ProcessUtilities.Run("dotnet", $"restore --project {projectPath}"); - server.AddClientLocalRpcTarget(ProjectDependencyHelper.ProjectNeedsRestoreName, new Action((projectFilePaths) => { })); - - // Listen for project initialization - var projectInitialized = new TaskCompletionSource(); - server.AddClientLocalRpcTarget(ProjectInitializationHandler.ProjectInitializationCompleteName, () => projectInitialized.SetResult()); - -#pragma warning disable RS0030 // Do not use banned APIs - await server.OpenProjectsAsync([new(projectPath)]); -#pragma warning restore RS0030 // Do not use banned APIs - - // Wait for initialization - await projectInitialized.Task; - - return server; + TempRoot.Dispose(); } - private protected static Dictionary> GetAnnotatedLocations(Uri codeUri, SourceText text, ImmutableDictionary> spanMap) + protected sealed class TestLspServer : ILspClient, IAsyncDisposable { - var locations = new Dictionary>(); - foreach (var (name, spans) in spanMap) + private readonly Task _languageServerHostCompletionTask; + private readonly JsonRpc _clientRpc; + + private ServerCapabilities? _serverCapabilities; + + internal static async Task CreateAsync(ClientCapabilities clientCapabilities, TestOutputLogger logger, string cacheDirectory, bool includeDevKitComponents = true, string[]? extensionPaths = null) { - var locationsForName = locations.GetValueOrDefault(name, []); - locationsForName.AddRange(spans.Select(span => ConvertTextSpanWithTextToLocation(span, text, codeUri))); + var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync( + logger.Factory, includeDevKitComponents, cacheDirectory, extensionPaths, out var _, out var assemblyLoader); + var testLspServer = new TestLspServer(exportProvider, logger, assemblyLoader); + var initializeResponse = await testLspServer.ExecuteRequestAsync(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None); + Assert.NotNull(initializeResponse?.Capabilities); + testLspServer._serverCapabilities = initializeResponse!.Capabilities; - // Linked files will return duplicate annotated Locations for each document that links to the same file. - // Since the test output only cares about the actual file, make sure we de-dupe before returning. - locations[name] = [.. locationsForName.Distinct()]; + await testLspServer.ExecuteRequestAsync(Methods.InitializedName, new InitializedParams(), CancellationToken.None); + + return testLspServer; } - return locations; + internal LanguageServerHost LanguageServerHost { get; } + public ExportProvider ExportProvider { get; } + + internal ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("Initialize has not been called"); - static LSP.Location ConvertTextSpanWithTextToLocation(TextSpan span, SourceText text, Uri documentUri) + private TestLspServer(ExportProvider exportProvider, TestOutputLogger logger, IAssemblyLoader assemblyLoader) { - var location = new LSP.Location + var typeRefResolver = new ExtensionTypeRefResolver(assemblyLoader, logger.Factory); + + var (clientStream, serverStream) = FullDuplexStream.CreatePair(); + LanguageServerHost = new LanguageServerHost(serverStream, serverStream, exportProvider, logger, typeRefResolver); + + var messageFormatter = RoslynLanguageServer.CreateJsonMessageFormatter(); + _clientRpc = new JsonRpc(new HeaderDelimitedMessageHandler(clientStream, clientStream, messageFormatter)) { - Uri = documentUri, - Range = ProtocolConversions.TextSpanToRange(span, text), + AllowModificationWhileListening = true, + ExceptionStrategy = ExceptionProcessing.ISerializable, }; - return location; + _clientRpc.StartListening(); + + // This task completes when the server shuts down. We store it so that we can wait for completion + // when we dispose of the test server. + LanguageServerHost.Start(); + + _languageServerHostCompletionTask = LanguageServerHost.WaitForExitAsync(); + ExportProvider = exportProvider; } - } - private protected static TextDocumentIdentifier CreateTextDocumentIdentifier(Uri uri, ProjectId? projectContext = null) - { - var documentIdentifier = new VSTextDocumentIdentifier { Uri = uri }; + public async Task ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class + { + var result = await _clientRpc.InvokeWithParameterObjectAsync(methodName, request, cancellationToken: cancellationToken); + return result; + } - if (projectContext != null) + public Task ExecuteNotificationAsync(string methodName, RequestType request) where RequestType : class { - documentIdentifier.ProjectContext = new VSProjectContext - { - Id = ProtocolConversions.ProjectIdToProjectContextId(projectContext), - Label = projectContext.DebugName!, - Kind = LSP.VSProjectKind.CSharp - }; + return _clientRpc.NotifyWithParameterObjectAsync(methodName, request); } - return documentIdentifier; - } + public Task ExecuteNotification0Async(string methodName) + { + return _clientRpc.NotifyWithParameterObjectAsync(methodName); + } - private protected static CodeActionParams CreateCodeActionParams(LSP.Location location) - => new() + public void AddClientLocalRpcTarget(object target) { - TextDocument = CreateTextDocumentIdentifier(location.Uri), - Range = location.Range, - Context = new CodeActionContext - { - // TODO - Code actions should respect context. - } - }; + _clientRpc.AddLocalRpcTarget(target); + } + + public void AddClientLocalRpcTarget(string methodName, Delegate handler) + { + _clientRpc.AddLocalRpcMethod(methodName, handler); + } + + public async ValueTask DisposeAsync() + { + await _clientRpc.InvokeAsync(Methods.ShutdownName); + await _clientRpc.NotifyAsync(Methods.ExitName); + + // The language server host task should complete once shutdown and exit are called. +#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks + await _languageServerHostCompletionTask; +#pragma warning restore VSTHRD003 // Avoid awaiting foreign Tasks + + _clientRpc.Dispose(); + } + } } diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/ILspClient.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/ILspClient.cs new file mode 100644 index 0000000000000..a5d564d6cb7e5 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/ILspClient.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +internal interface ILspClient +{ + Task ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class; + + Task ExecuteNotificationAsync(string methodName, RequestType request) where RequestType : class; + Task ExecuteNotification0Async(string methodName); + + void AddClientLocalRpcTarget(object target); + void AddClientLocalRpcTarget(string methodName, Delegate handler); +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs index 0b02df824fb89..9667713fc60bc 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs @@ -10,16 +10,6 @@ namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; internal sealed class LanguageServerTestComposition { - /// - /// Build places DevKit files to this subdirectory. - /// - private const string DevKitExtensionSubdirectory = "DevKit"; - - private const string DevKitAssemblyFileName = "Microsoft.VisualStudio.LanguageServices.DevKit.dll"; - - private static string GetDevKitExtensionPath() - => Path.Combine(AppContext.BaseDirectory, DevKitExtensionSubdirectory, DevKitAssemblyFileName); - public static Task CreateExportProviderAsync( ILoggerFactory loggerFactory, bool includeDevKitComponents, @@ -28,7 +18,7 @@ public static Task CreateExportProviderAsync( out ServerConfiguration serverConfiguration, out IAssemblyLoader assemblyLoader) { - var devKitDependencyPath = includeDevKitComponents ? GetDevKitExtensionPath() : null; + var devKitDependencyPath = includeDevKitComponents ? TestPaths.GetDevKitExtensionPath() : null; serverConfiguration = new ServerConfiguration(LaunchDebugger: false, LogConfiguration: new LogConfiguration(LogLevel.Trace), StarredCompletionsPath: null, diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LspClientExtensions.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LspClientExtensions.cs new file mode 100644 index 0000000000000..c06d676760157 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LspClientExtensions.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; +using Roslyn.LanguageServer.Protocol; + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +internal static class LspClientExtensions +{ + public static async Task Initialized(this ILspClient lspClient) + { + await lspClient.ExecuteRequestAsync(Methods.InitializedName, new InitializedParams(), CancellationToken.None); + } + + public static async Task Initialize(this ILspClient lspClient, ClientCapabilities clientCapabilities) + { + return await lspClient.ExecuteRequestAsync(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None); + } + + public static async Task OpenProjectsAsync(this ILspClient lspClient, Uri[] projects) + { + await lspClient.ExecuteNotificationAsync(OpenProjectHandler.OpenProjectName, new() { Projects = projects }); + } + + public static async Task RunGetCodeActionsAsync( + this ILspClient lspClient, + CodeActionParams codeActionParams) + { + var result = await lspClient.ExecuteRequestAsync(Methods.TextDocumentCodeActionName, codeActionParams, CancellationToken.None); + Assert.NotNull(result); + return [.. result.Cast()]; + } + + public static async Task RunGetCodeActionResolveAsync( + this ILspClient lspClient, + VSInternalCodeAction unresolvedCodeAction) + { + var result = (VSInternalCodeAction?)await lspClient.ExecuteRequestAsync(Methods.CodeActionResolveName, unresolvedCodeAction, CancellationToken.None); + Assert.NotNull(result); + return result; + } +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs deleted file mode 100644 index ac304ae173487..0000000000000 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestLspServerExtensions.cs +++ /dev/null @@ -1,45 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace; -using Roslyn.LanguageServer.Protocol; -using static Microsoft.CodeAnalysis.LanguageServer.UnitTests.AbstractLanguageServerHostTests; - -namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; - -internal static class TestLspServerExtensions -{ - public static async Task Initialized(this TestLspServer testLspServer) - { - await testLspServer.ExecuteRequestAsync(Methods.InitializedName, new InitializedParams(), CancellationToken.None); - } - - public static async Task Initialize(this TestLspServer testLspServer, ClientCapabilities clientCapabilities) - { - return await testLspServer.ExecuteRequestAsync(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None); - } - - public static async Task OpenProjectsAsync(this TestLspServer testLspServer, Uri[] projects) - { - await testLspServer.ExecuteNotificationAsync(OpenProjectHandler.OpenProjectName, new() { Projects = projects }); - } - - public static async Task RunGetCodeActionsAsync( - this TestLspServer testLspServer, - CodeActionParams codeActionParams) - { - var result = await testLspServer.ExecuteRequestAsync(Methods.TextDocumentCodeActionName, codeActionParams, CancellationToken.None); - Assert.NotNull(result); - return [.. result.Cast()]; - } - - public static async Task RunGetCodeActionResolveAsync( - this TestLspServer testLspServer, - VSInternalCodeAction unresolvedCodeAction) - { - var result = (VSInternalCodeAction?)await testLspServer.ExecuteRequestAsync(Methods.CodeActionResolveName, unresolvedCodeAction, CancellationToken.None); - Assert.NotNull(result); - return result; - } -} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestPaths.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestPaths.cs new file mode 100644 index 0000000000000..5b392926b53c4 --- /dev/null +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/TestPaths.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; + +internal static class TestPaths +{ + /// + /// Build places DevKit files to this subdirectory. + /// + private const string DevKitExtensionSubdirectory = "DevKit"; + private const string DevKitAssemblyFileName = "Microsoft.VisualStudio.LanguageServices.DevKit.dll"; + + public static string GetDevKitExtensionPath() + => Path.Combine(AppContext.BaseDirectory, DevKitExtensionSubdirectory, DevKitAssemblyFileName); + + /// + /// Build places RoslynLSP files to this subdirectory. + /// + private const string LanguageServerSubdirectory = "RoslynLSP"; + private const string LanguageServerAssemblyFileName = "Microsoft.CodeAnalysis.LanguageServer.dll"; + + public static string GetLanguageServerPath() + => Path.Combine(AppContext.BaseDirectory, LanguageServerSubdirectory, LanguageServerAssemblyFileName); +} diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj index e4d766433e2d1..8495f7c23803e 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj @@ -121,6 +121,16 @@ + + + + <_LanguageServerOutputPath>$(OutputPath) + + + diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/WindowsErrorReporting.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/WindowsErrorReporting.cs index f11f0b62d8cb4..263ed8bf49c13 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/WindowsErrorReporting.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/WindowsErrorReporting.cs @@ -14,18 +14,20 @@ internal static void SetErrorModeOnWindows() return; } - SetErrorMode(ErrorModes.SYSTEM_DEFAULT); + var oldErrorMode = SetErrorMode(ErrorModes.SYSTEM_DEFAULT); // There have been reports that SetErrorMode wasn't working correctly, so double - // check in Debug builds that it actually set - Debug.Assert(GetErrorMode() == (uint)ErrorModes.SYSTEM_DEFAULT); + // check in Debug builds that it actually set. The SEM_NOALIGNMENTFAULTEXCEPT mode + // is special because it cannot be cleared once it is set. + // Refer to https://learn.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-seterrormode + Debug.Assert(GetErrorMode() == (oldErrorMode & ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT)); } [DllImport("kernel32.dll")] private static extern ErrorModes SetErrorMode(ErrorModes uMode); [DllImport("kernel32.dll")] - private static extern uint GetErrorMode(); + private static extern ErrorModes GetErrorMode(); [Flags] private enum ErrorModes : uint From dfd0a2af0c6b861be0757f2276cc20a756f9fd94 Mon Sep 17 00:00:00 2001 From: Jason Malinowski Date: Wed, 15 Jan 2025 17:55:39 -0800 Subject: [PATCH 10/76] Turn off ngen for Microsoft.CodeAnalysis.Workspaces.MSBuild The number of users this could help is very, very tiny, and the number of ways it could cause further problems is much, much higher. --- src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj index 8e34c513a30e9..b5ac90cd714de 100644 --- a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj +++ b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj @@ -173,6 +173,12 @@ true TargetFramework=net472 BindingRedirect + + + false CSharpWorkspace From a00b07a148e011e657bd753ffc458a138c854f50 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Thu, 16 Jan 2025 14:40:21 -0800 Subject: [PATCH 11/76] Applied review feedback. --- ...deAnalysis.LanguageServer.UnitTests.csproj | 8 ++- ...LanguageServerClientTests.TestLspClient.cs | 19 ++--- .../AbstractLanguageServerClientTests.cs | 70 +++---------------- ...crosoft.CodeAnalysis.LanguageServer.csproj | 10 --- 4 files changed, 22 insertions(+), 85 deletions(-) diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj index 4f65ae85bd18d..1a0f088e2eed0 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj @@ -31,10 +31,14 @@ Copy files contained in the project to a RoslynLSP subdirectory to emulate deployment of the language server. --> - - + + + + <_LanguageServerOutputPath>$([System.IO.Path]::GetDirectoryName(%(_LanguageServerFilePath.Identity))) + + <_LanguageServerFile Include="$(_LanguageServerOutputPath)\**\*.*" /> <_LanguageServerFile Remove="$(_LanguageServerOutputPath)\**\*.mef-composition" /> diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs index 07c0fec996e34..1adddb300ea64 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs @@ -85,11 +85,10 @@ static ProcessStartInfo CreateLspStartInfo(string pipeName, string extensionLogs FileName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet", }; - // We need to roll forward to the latest runtime, since the tests may be using a runtime newer than we ourselves built with. - // We set the environment variable since --roll-forward LatestMajor doesn't roll forward to prerelease runtimes otherwise. + // The LSP's runtime configuration sets rollforward to Major which allows it to run on a newer runtime + // when the expected runtime is not present. Additionally, we need to be able to use prerelease runtimes + // since unit tests may be running against preview builds of the .NET SDK. processStartInfo.Environment["DOTNET_ROLL_FORWARD_TO_PRERELEASE"] = "1"; - processStartInfo.ArgumentList.Add("--roll-forward"); - processStartInfo.ArgumentList.Add("LatestMajor"); processStartInfo.ArgumentList.Add(TestPaths.GetLanguageServerPath()); @@ -133,7 +132,6 @@ private TestLspClient(Process process, string pipeName, Dictionary ExecuteRequestAsync(string methodName, TRequestType request, CancellationToken cancellationToken) where TRequestType : class { var result = await _clientRpc.InvokeWithParameterObjectAsync(methodName, request, cancellationToken); @@ -267,9 +258,9 @@ public async ValueTask DisposeAsync() await _clientRpc.InvokeAsync(Methods.ShutdownName); await _clientRpc.NotifyAsync(Methods.ExitName); - } - await _clientRpc.Completion; + await _clientRpc.Completion; + } _clientRpc.Dispose(); _process.Dispose(); diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs index 7e95ea26647a4..c0c2fff89759d 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs @@ -16,11 +16,8 @@ namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests; -public abstract partial class AbstractLanguageServerClientTests(ITestOutputHelper testOutputHelper) : IAsyncLifetime +public abstract partial class AbstractLanguageServerClientTests(ITestOutputHelper testOutputHelper) : IDisposable { - private readonly SemaphoreSlim _gate = new(initialCount: 1); - private readonly List _lspClients = []; - protected TestOutputLogger TestOutputLogger => new(testOutputHelper); protected TempRoot TempRoot => new(); protected TempDirectory ExtensionLogsDirectory => TempRoot.CreateDirectory(); @@ -30,22 +27,9 @@ public Task InitializeAsync() return Task.CompletedTask; } - public async Task DisposeAsync() + public void Dispose() { TempRoot.Dispose(); - - List clientsToDispose; - - // Copy the list out while we're in the lock, otherwise as we dispose these events will get fired, which - // may try to mutate the list while we're enumerating. - using (await _gate.DisposableWaitAsync().ConfigureAwait(false)) - { - clientsToDispose = [.. _lspClients]; - _lspClients.Clear(); - } - - foreach (var client in clientsToDispose) - await client.DisposeAsync().ConfigureAwait(false); } private protected async Task CreateCSharpLanguageServerAsync( @@ -81,21 +65,15 @@ await File.WriteAllTextAsync(projectPath, $""" Dictionary files = new() { [codeUri] = text }; var annotatedLocations = GetAnnotatedLocations(codeUri, text, spans); - TestLspClient? lspClient; - using (await _gate.DisposableWaitAsync().ConfigureAwait(false)) - { - // Create server and open the project - lspClient = await TestLspClient.CreateAsync( - new ClientCapabilities(), - ExtensionLogsDirectory.Path, - includeDevKitComponents, - debugLsp, - TestOutputLogger, - documents: files, - locations: annotatedLocations); - lspClient.Disconnected += LSP_Disconnected; - _lspClients.Add(lspClient); - } + // Create server and open the project + var lspClient = await TestLspClient.CreateAsync( + new ClientCapabilities(), + ExtensionLogsDirectory.Path, + includeDevKitComponents, + debugLsp, + TestOutputLogger, + documents: files, + locations: annotatedLocations); // Perform restore and mock up project restore client handler ProcessUtilities.Run("dotnet", $"restore --project {projectPath}"); @@ -115,32 +93,6 @@ await File.WriteAllTextAsync(projectPath, $""" return lspClient; } - private void LSP_Disconnected(object? sender, EventArgs e) - { - Contract.ThrowIfNull(sender, $"{nameof(TestLspClient)}.{nameof(TestLspClient.Disconnected)} was raised with a null sender."); - - Task.Run(async () => - { - TestLspClient? clientToDispose = null; - - using (await _gate.DisposableWaitAsync().ConfigureAwait(false)) - { - // Remove it from our map; it's possible it might have already been removed if we had more than one way we observed a disconnect. - clientToDispose = _lspClients.FirstOrDefault(c => c == sender); - if (clientToDispose is not null) - { - _lspClients.Remove(clientToDispose); - } - } - - // Dispose outside of the lock (even though we don't expect much to happen at this point) - if (clientToDispose is not null) - { - await clientToDispose.DisposeAsync().ConfigureAwait(false); - } - }); - } - private protected static Dictionary> GetAnnotatedLocations(Uri codeUri, SourceText text, ImmutableDictionary> spanMap) { var locations = new Dictionary>(); diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj index 8495f7c23803e..e4d766433e2d1 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj @@ -121,16 +121,6 @@ - - - - <_LanguageServerOutputPath>$(OutputPath) - - - From 516f16ace21adcd620fb52177a54bcf87e813e76 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Thu, 16 Jan 2025 15:41:03 -0800 Subject: [PATCH 12/76] Applied review feedback. --- .../Utilities/AbstractLanguageServerClientTests.cs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs index c0c2fff89759d..72fd371bb1504 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.cs @@ -22,11 +22,6 @@ public abstract partial class AbstractLanguageServerClientTests(ITestOutputHelpe protected TempRoot TempRoot => new(); protected TempDirectory ExtensionLogsDirectory => TempRoot.CreateDirectory(); - public Task InitializeAsync() - { - return Task.CompletedTask; - } - public void Dispose() { TempRoot.Dispose(); @@ -45,11 +40,14 @@ private protected async Task CreateCSharpLanguageServerAsync( // Write project file var projectDirectory = TempRoot.CreateDirectory(); var projectPath = Path.Combine(projectDirectory.Path, "Project.csproj"); + + // To ensure our TargetFramework is buildable in each test environment we are + // setting it to match the $(NetVSCode) version. await File.WriteAllTextAsync(projectPath, $""" Library - net{Environment.Version.Major}.0 + net8.0 """); From ee3f33bac4769953a6562855b77ed6479976a890 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Thu, 16 Jan 2025 16:06:20 -0800 Subject: [PATCH 13/76] Do not catch exceptions when disposing TestLspClient --- ...LanguageServerClientTests.TestLspClient.cs | 29 ++++++------------- 1 file changed, 9 insertions(+), 20 deletions(-) diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs index 1adddb300ea64..d3dcb2f7f6b91 100644 --- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs +++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerClientTests.TestLspClient.cs @@ -249,31 +249,20 @@ public async ValueTask DisposeAsync() if (Interlocked.CompareExchange(ref _disposed, value: 1, comparand: 0) != 0) return; - // We will call Shutdown in a try/catch; if the process has gone bad it's possible the connection is no longer functioning. - try + if (!_process.HasExited) { - if (!_process.HasExited) - { - _logger.LogTrace("Sending a Shutdown request to the LSP."); - - await _clientRpc.InvokeAsync(Methods.ShutdownName); - await _clientRpc.NotifyAsync(Methods.ExitName); - - await _clientRpc.Completion; - } + _logger.LogTrace("Sending a Shutdown request to the LSP."); - _clientRpc.Dispose(); - _process.Dispose(); + await _clientRpc.InvokeAsync(Methods.ShutdownName); + await _clientRpc.NotifyAsync(Methods.ExitName); - _logger.LogTrace("Process shut down."); + await _clientRpc.Completion; } - catch (Exception e) - { - _logger.LogError(e, "Exception while shutting down the LSP process."); - // Process may have gone bad, so not much else we can do. - _process.Kill(); - } + _clientRpc.Dispose(); + _process.Dispose(); + + _logger.LogTrace("Process shut down."); } } } From bf430202bfeb6aaf406763718bd3b36adcefffdb Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 21 Jan 2025 20:17:31 -0800 Subject: [PATCH 14/76] Push diagnostic suppression filtering flag to feature levels --- ....SingleDiagnosticKindPullTaggerProvider.cs | 1 - .../Test/CodeFixes/CodeFixServiceTests.cs | 6 ++- .../DiagnosticAnalyzerServiceTests.cs | 11 ++-- .../Diagnostics/DiagnosticProviderTests.vb | 2 +- .../Diagnostics/DiagnosticServiceTests.vb | 33 ++++++------ .../MockDiagnosticAnalyzerService.cs | 10 ++-- .../CodeAnalysisDiagnosticAnalyzerService.cs | 48 ++++++++++++------ .../Diagnostics/DiagnosticArguments.cs | 26 ++++------ .../Diagnostics/IDiagnosticAnalyzerService.cs | 50 ++++++++++--------- .../TestDiagnosticAnalyzerDriver.cs | 6 ++- .../CodeCleanup/AbstractCodeCleanupService.cs | 9 ++-- ...CodeFixService.FixAllDiagnosticProvider.cs | 21 +++----- .../Features/CodeFixes/CodeFixService.cs | 17 +++++-- .../Diagnostics/DiagnosticAnalyzerService.cs | 18 +++---- .../DocumentAnalysisExecutor_Helpers.cs | 5 +- ...cIncrementalAnalyzer.CompilationManager.cs | 11 ++-- .../DiagnosticIncrementalAnalyzer.Executor.cs | 1 - ...alyzer.InProcOrRemoteHostAnalyzerRunner.cs | 4 +- ...osticIncrementalAnalyzer_GetDiagnostics.cs | 29 ++++------- ...crementalAnalyzer_GetDiagnosticsForSpan.cs | 16 ++---- ...IncrementalAnalyzer_IncrementalAnalyzer.cs | 2 +- .../AbstractProjectDiagnosticSource.cs | 8 ++- ...stractWorkspaceDocumentDiagnosticSource.cs | 5 +- .../DocumentDiagnosticSource.cs | 5 +- .../NonLocalDocumentDiagnosticSource.cs | 13 +++-- .../VisualStudioSuppressionFixService.cs | 4 +- .../ExternalDiagnosticUpdateSourceTests.vb | 8 +-- .../Venus/DocumentService_IntegrationTests.vb | 2 +- .../CompilationWithAnalyzersPair.cs | 2 - .../Core/Portable/Diagnostics/Extensions.cs | 34 ++++++------- .../DiagnosticAnalyzer/DiagnosticComputer.cs | 17 +++---- .../RemoteDiagnosticAnalyzerService.cs | 1 - 32 files changed, 210 insertions(+), 215 deletions(-) diff --git a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs index e56886d8cdcad..d38f7a89b74eb 100644 --- a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs +++ b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs @@ -128,7 +128,6 @@ private async Task ProduceTagsAsync( document, requestedSpan.Span.ToTextSpan(), diagnosticKind: _diagnosticKind, - includeSuppressedDiagnostics: true, cancellationToken: cancellationToken).ConfigureAwait(false); // Copilot code analysis is a special analyzer that reports semantic correctness diff --git a/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs b/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs index 5d9394ee00cb2..1b777a72a585c 100644 --- a/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs +++ b/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs @@ -1078,7 +1078,7 @@ void M() await diagnosticIncrementalAnalyzer.GetDiagnosticsForIdsAsync( sourceDocument.Project.Solution, sourceDocument.Project.Id, sourceDocument.Id, diagnosticIds: null, shouldIncludeAnalyzer: null, getDocuments: null, - includeSuppressedDiagnostics: true, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, CancellationToken.None); + includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, CancellationToken.None); await diagnosticIncrementalAnalyzer.GetTestAccessor().TextDocumentOpenAsync(sourceDocument); var lowPriorityAnalyzerData = new SuggestedActionPriorityProvider.LowPriorityAnalyzersAndDiagnosticIds(); @@ -1142,7 +1142,9 @@ static bool GetExpectDeprioritization( static async Task VerifyCachedDiagnosticsAsync(Document sourceDocument, bool expectedCachedDiagnostic, TextSpan testSpan, DiagnosticIncrementalAnalyzer diagnosticIncrementalAnalyzer) { var cachedDiagnostics = await diagnosticIncrementalAnalyzer.GetCachedDiagnosticsAsync(sourceDocument.Project.Solution, sourceDocument.Project.Id, sourceDocument.Id, - includeSuppressedDiagnostics: false, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, CancellationToken.None); + includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, CancellationToken.None); + cachedDiagnostics = cachedDiagnostics.WhereAsArray(d => !d.IsSuppressed); + if (!expectedCachedDiagnostic) { Assert.Empty(cachedDiagnostics); diff --git a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs index 204f0c4473ba7..708f4c17c98db 100644 --- a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs +++ b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs @@ -69,7 +69,8 @@ public async Task TestHasSuccessfullyLoadedBeingFalse() var diagnostics = await analyzer.GetDiagnosticsForIdsAsync( workspace.CurrentSolution, projectId: null, documentId: null, diagnosticIds: null, shouldIncludeAnalyzer: null, getDocuments: null, - includeSuppressedDiagnostics: false, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, CancellationToken.None); + includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, CancellationToken.None); + diagnostics = diagnostics.WhereAsArray(d => !d.IsSuppressed); Assert.NotEmpty(diagnostics); } @@ -705,7 +706,7 @@ internal async Task TestOnlyRequiredAnalyzerExecutedDuringDiagnosticComputation( var diagnosticsMapResults = await DiagnosticComputer.GetDiagnosticsAsync( document, project, Checksum.Null, span: null, projectAnalyzerIds: [], analyzerIdsToRequestDiagnostics, AnalysisKind.Semantic, new DiagnosticAnalyzerInfoCache(), workspace.Services, - isExplicit: false, reportSuppressedDiagnostics: false, logPerformanceInfo: false, getTelemetryInfo: false, + isExplicit: false, logPerformanceInfo: false, getTelemetryInfo: false, cancellationToken: CancellationToken.None); Assert.False(analyzer2.ReceivedSymbolCallback); @@ -773,7 +774,7 @@ async Task VerifyCallbackSpanAsync(TextSpan? filterSpan) _ = await DiagnosticComputer.GetDiagnosticsAsync( documentToAnalyze, project, Checksum.Null, filterSpan, analyzerIdsToRequestDiagnostics, hostAnalyzerIds: [], analysisKind, new DiagnosticAnalyzerInfoCache(), workspace.Services, - isExplicit: false, reportSuppressedDiagnostics: false, logPerformanceInfo: false, getTelemetryInfo: false, + isExplicit: false, logPerformanceInfo: false, getTelemetryInfo: false, CancellationToken.None); Assert.Equal(filterSpan, analyzer.CallbackFilterSpan); if (kind == FilterSpanTestAnalyzer.AnalysisKind.AdditionalFile) @@ -827,7 +828,7 @@ void M() try { _ = await DiagnosticComputer.GetDiagnosticsAsync(document, project, Checksum.Null, span: null, - projectAnalyzerIds: [], analyzerIds, kind, diagnosticAnalyzerInfoCache, workspace.Services, isExplicit: false, reportSuppressedDiagnostics: false, + projectAnalyzerIds: [], analyzerIds, kind, diagnosticAnalyzerInfoCache, workspace.Services, isExplicit: false, logPerformanceInfo: false, getTelemetryInfo: false, cancellationToken: analyzer.CancellationToken); throw ExceptionUtilities.Unreachable(); @@ -840,7 +841,7 @@ void M() // Then invoke analysis without cancellation token, and verify non-cancelled diagnostic. var diagnosticsMap = await DiagnosticComputer.GetDiagnosticsAsync(document, project, Checksum.Null, span: null, - projectAnalyzerIds: [], analyzerIds, kind, diagnosticAnalyzerInfoCache, workspace.Services, isExplicit: false, reportSuppressedDiagnostics: false, + projectAnalyzerIds: [], analyzerIds, kind, diagnosticAnalyzerInfoCache, workspace.Services, isExplicit: false, logPerformanceInfo: false, getTelemetryInfo: false, cancellationToken: CancellationToken.None); var builder = diagnosticsMap.Diagnostics.Single().diagnosticMap; var diagnostic = kind == AnalysisKind.Syntax ? builder.Syntax.Single().Item2.Single() : builder.Semantic.Single().Item2.Single(); diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb index 088b930be272f..60e9364a22935 100644 --- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb +++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb @@ -263,7 +263,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests Dim diagnosticProvider = GetDiagnosticProvider(workspace) Dim actualDiagnostics = diagnosticProvider.GetDiagnosticsForIdsAsync( workspace.CurrentSolution, projectId:=Nothing, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None).Result + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None).Result If diagnostics Is Nothing Then Assert.Equal(0, actualDiagnostics.Length) diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb index 6b4f31e62f29d..f6f873d4aaa76 100644 --- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb +++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb @@ -10,6 +10,7 @@ Imports Microsoft.CodeAnalysis Imports Microsoft.CodeAnalysis.CodeActions Imports Microsoft.CodeAnalysis.CommonDiagnosticAnalyzers Imports Microsoft.CodeAnalysis.CSharp +Imports Microsoft.CodeAnalysis.CSharp.Syntax Imports Microsoft.CodeAnalysis.Diagnostics Imports Microsoft.CodeAnalysis.Diagnostics.CSharp Imports Microsoft.CodeAnalysis.Editor.UnitTests @@ -65,7 +66,8 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests End Function Private Shared Async Function GetDiagnosticsForSpanAsync(diagnosticService As IDiagnosticAnalyzerService, document As Document, range As TextSpan, diagnosticKind As DiagnosticKind) As Task(Of ImmutableArray(Of DiagnosticData)) - Return Await diagnosticService.GetDiagnosticsForSpanAsync(document, range, diagnosticKind, includeSuppressedDiagnostics:=False, CancellationToken.None) + Dim diagnostics = Await diagnosticService.GetDiagnosticsForSpanAsync(document, range, diagnosticKind, CancellationToken.None) + Return diagnostics.WhereAsArray(Function(d) Not d.IsSuppressed) End Function @@ -538,7 +540,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, projectId:=Nothing, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Dim diagnostic = diagnostics.First() Assert.True(diagnostic.Id = "AD0001") Assert.Contains("CodeBlockStartedAnalyzer", diagnostic.Message, StringComparison.Ordinal) @@ -609,7 +611,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests Dim document = project.Documents.Single() Dim diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Assert.Equal(1, diagnostics.Count()) Dim diagnostic = diagnostics.First() Assert.Equal(OperationAnalyzer.Descriptor.Id, diagnostic.Id) @@ -805,9 +807,10 @@ class AnonymousFunctions ' Test "GetDiagnosticsForIdsAsync" does force computation of compilation end diagnostics. ' Verify compilation diagnostics are reported with correct location info when asked for project diagnostics. - Dim projectDiagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId:=Nothing, - diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, includeSuppressedDiagnostics:=False, - includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + Dim projectDiagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( + project.Solution, project.Id, documentId:=Nothing, + diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Assert.Equal(2, projectDiagnostics.Count()) Dim noLocationDiagnostic = projectDiagnostics.First(Function(d) d.DataLocation.DocumentId Is Nothing) @@ -951,7 +954,7 @@ class AnonymousFunctions Dim document = project.Documents.Single() Dim diagnostics = (Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)). + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)). Select(Function(d) d.Id = NamedTypeAnalyzer.DiagDescriptor.Id) Assert.Equal(1, diagnostics.Count) @@ -1046,7 +1049,7 @@ class AnonymousFunctions Dim incrementalAnalyzer = diagnosticService.CreateIncrementalAnalyzer(workspace) Dim diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Assert.Equal(2, diagnostics.Count()) Dim file1HasDiag = False, file2HasDiag = False For Each diagnostic In diagnostics @@ -2135,11 +2138,11 @@ class MyClass Assert.Equal(analyzer.Descriptor.Id, descriptors.Single().Id) ' Get cached project diagnostics. - Dim diagnostics = Await diagnosticService.GetCachedDiagnosticsAsync(workspace, project.Id, documentId:=Nothing, - includeSuppressedDiagnostics:=False, - includeLocalDocumentDiagnostics:=True, - includeNonLocalDocumentDiagnostics:=True, - CancellationToken.None) + Dim diagnostics = Await diagnosticService.GetCachedDiagnosticsAsync( + workspace, project.Id, documentId:=Nothing, + includeLocalDocumentDiagnostics:=True, + includeNonLocalDocumentDiagnostics:=True, + CancellationToken.None) ' in v2, solution crawler never creates non-local hidden diagnostics. ' v2 still creates those for LB and explicit queries such as FixAll. @@ -2149,7 +2152,7 @@ class MyClass ' Get diagnostics explicitly Dim hiddenDiagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Assert.Equal(1, hiddenDiagnostics.Count()) Assert.Equal(analyzer.Descriptor.Id, hiddenDiagnostics.Single().Id) End Using @@ -2236,7 +2239,7 @@ class C Dim incrementalAnalyzer = diagnosticService.CreateIncrementalAnalyzer(workspace) Dim diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Assert.Equal(0, diagnostics.Count()) End Using End Function diff --git a/src/EditorFeatures/TestUtilities/Diagnostics/MockDiagnosticAnalyzerService.cs b/src/EditorFeatures/TestUtilities/Diagnostics/MockDiagnosticAnalyzerService.cs index 1d58ca00a5b09..7c4baeeb75e67 100644 --- a/src/EditorFeatures/TestUtilities/Diagnostics/MockDiagnosticAnalyzerService.cs +++ b/src/EditorFeatures/TestUtilities/Diagnostics/MockDiagnosticAnalyzerService.cs @@ -55,19 +55,19 @@ public bool ContainsDiagnostics(Workspace workspace, ProjectId projectId) public Task ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken) => throw new NotImplementedException(); - public Task> GetCachedDiagnosticsAsync(Workspace workspace, ProjectId? projectId, DocumentId? documentId, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + public Task> GetCachedDiagnosticsAsync(Workspace workspace, ProjectId? projectId, DocumentId? documentId, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) => throw new NotImplementedException(); - public Task> GetDiagnosticsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, bool includeSuppressedDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + public Task> GetDiagnosticsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) => throw new NotImplementedException(); - public Task> GetDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + public Task> GetDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) => throw new NotImplementedException(); - public Task> GetDiagnosticsForSpanAsync(TextDocument document, TextSpan? range, Func? shouldIncludeDiagnostic, bool includeCompilerDiagnostics, bool includeSuppressedDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, DiagnosticKind diagnosticKind, bool isExplicit, CancellationToken cancellationToken) + public Task> GetDiagnosticsForSpanAsync(TextDocument document, TextSpan? range, Func? shouldIncludeDiagnostic, bool includeCompilerDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, DiagnosticKind diagnosticKind, bool isExplicit, CancellationToken cancellationToken) => Task.FromResult(_diagnosticsWithKindFilter.Where(d => diagnosticKind == d.KindFilter).Select(d => d.Diagnostic).ToImmutableArray()); - public Task> GetProjectDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeSuppressedDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + public Task> GetProjectDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) => throw new NotImplementedException(); } } diff --git a/src/Features/Core/Portable/Diagnostics/CodeAnalysisDiagnosticAnalyzerService.cs b/src/Features/Core/Portable/Diagnostics/CodeAnalysisDiagnosticAnalyzerService.cs index d215f1a95815a..cc52cd179ee96 100644 --- a/src/Features/Core/Portable/Diagnostics/CodeAnalysisDiagnosticAnalyzerService.cs +++ b/src/Features/Core/Portable/Diagnostics/CodeAnalysisDiagnosticAnalyzerService.cs @@ -134,25 +134,41 @@ private async ValueTask AnalyzeProjectCoreAsync(Project project, Action } /// - /// Running code analysis on the project force computes and caches the diagnostics on the DiagnosticAnalyzerService. - /// We return these cached document diagnostics here, including both local and non-local document diagnostics. + /// Running code analysis on the project force computes and caches the diagnostics on the + /// DiagnosticAnalyzerService. We return these cached document diagnostics here, including both local and + /// non-local document diagnostics. /// - public Task> GetLastComputedDocumentDiagnosticsAsync(DocumentId documentId, CancellationToken cancellationToken) - => _clearedProjectIds.Contains(documentId.ProjectId) - ? SpecializedTasks.EmptyImmutableArray() - : _diagnosticAnalyzerService.GetCachedDiagnosticsAsync(_workspace, documentId.ProjectId, - documentId, includeSuppressedDiagnostics: false, includeLocalDocumentDiagnostics: true, - includeNonLocalDocumentDiagnostics: true, cancellationToken); + /// + /// Only returns non-suppressed diagnostics. + /// + public async Task> GetLastComputedDocumentDiagnosticsAsync(DocumentId documentId, CancellationToken cancellationToken) + { + if (_clearedProjectIds.Contains(documentId.ProjectId)) + return []; + + var diagnostics = await _diagnosticAnalyzerService.GetCachedDiagnosticsAsync( + _workspace, documentId.ProjectId, documentId, includeLocalDocumentDiagnostics: true, + includeNonLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false); + return diagnostics.WhereAsArray(d => !d.IsSuppressed); + } /// - /// Running code analysis on the project force computes and caches the diagnostics on the DiagnosticAnalyzerService. - /// We return these cached project diagnostics here, i.e. diagnostics with no location, by excluding all local and non-local document diagnostics. + /// Running code analysis on the project force computes and caches the diagnostics on the + /// DiagnosticAnalyzerService. We return these cached project diagnostics here, i.e. diagnostics with no + /// location, by excluding all local and non-local document diagnostics. /// - public Task> GetLastComputedProjectDiagnosticsAsync(ProjectId projectId, CancellationToken cancellationToken) - => _clearedProjectIds.Contains(projectId) - ? SpecializedTasks.EmptyImmutableArray() - : _diagnosticAnalyzerService.GetCachedDiagnosticsAsync(_workspace, projectId, documentId: null, - includeSuppressedDiagnostics: false, includeLocalDocumentDiagnostics: false, - includeNonLocalDocumentDiagnostics: false, cancellationToken); + /// + /// Only returns non-suppressed diagnostics. + /// + public async Task> GetLastComputedProjectDiagnosticsAsync(ProjectId projectId, CancellationToken cancellationToken) + { + if (_clearedProjectIds.Contains(projectId)) + return []; + + var diagnostics = await _diagnosticAnalyzerService.GetCachedDiagnosticsAsync( + _workspace, projectId, documentId: null, includeLocalDocumentDiagnostics: false, + includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + return diagnostics.WhereAsArray(d => !d.IsSuppressed); + } } } diff --git a/src/Features/Core/Portable/Diagnostics/DiagnosticArguments.cs b/src/Features/Core/Portable/Diagnostics/DiagnosticArguments.cs index fa573e85c5018..4108a704423ae 100644 --- a/src/Features/Core/Portable/Diagnostics/DiagnosticArguments.cs +++ b/src/Features/Core/Portable/Diagnostics/DiagnosticArguments.cs @@ -15,38 +15,32 @@ namespace Microsoft.CodeAnalysis.Diagnostics; [DataContract] internal sealed class DiagnosticArguments { - /// - /// Flag indicating if suppressed diagnostics should be returned. - /// - [DataMember(Order = 0)] - public bool ReportSuppressedDiagnostics; - /// /// Flag indicating if analyzer performance info, such as analyzer execution times, /// should be logged as performance telemetry. /// - [DataMember(Order = 1)] + [DataMember(Order = 0)] public bool LogPerformanceInfo; /// /// Flag indicating if the analyzer telemety info, such as registered analyzer action counts /// and analyzer execution times, should be included in the computed result. /// - [DataMember(Order = 2)] + [DataMember(Order = 1)] public bool GetTelemetryInfo; /// /// Optional document ID, if computing diagnostics for a specific document. /// For example, diagnostic computation for open file analysis. /// - [DataMember(Order = 3)] + [DataMember(Order = 2)] public DocumentId? DocumentId; /// /// Optional document text span, if computing diagnostics for a specific span for a document. /// For example, diagnostic computation for light bulb invocation for a specific line in active document. /// - [DataMember(Order = 4)] + [DataMember(Order = 3)] public TextSpan? DocumentSpan; /// @@ -54,36 +48,35 @@ internal sealed class DiagnosticArguments /// i.e. must be non-null for a non-null analysis kind. /// Only supported non-null values are and . /// - [DataMember(Order = 5)] + [DataMember(Order = 4)] public AnalysisKind? DocumentAnalysisKind; /// /// Project ID for the document or project for which diagnostics need to be computed. /// - [DataMember(Order = 6)] + [DataMember(Order = 5)] public ProjectId ProjectId; /// /// Array of analyzer IDs for analyzers that need to be executed for computing diagnostics. /// - [DataMember(Order = 7)] + [DataMember(Order = 6)] public ImmutableArray ProjectAnalyzerIds; /// /// Array of analyzer IDs for analyzers that need to be executed for computing diagnostics. /// - [DataMember(Order = 8)] + [DataMember(Order = 7)] public ImmutableArray HostAnalyzerIds; /// /// Indicates diagnostic computation for an explicit user-invoked request, /// such as a user-invoked Ctrl + Dot operation to bring up the light bulb. /// - [DataMember(Order = 9)] + [DataMember(Order = 8)] public bool IsExplicit; public DiagnosticArguments( - bool reportSuppressedDiagnostics, bool logPerformanceInfo, bool getTelemetryInfo, DocumentId? documentId, @@ -100,7 +93,6 @@ public DiagnosticArguments( (AnalysisKind?)AnalysisKind.Syntax or (AnalysisKind?)AnalysisKind.Semantic); Debug.Assert(projectAnalyzerIds.Length > 0 || hostAnalyzerIds.Length > 0); - ReportSuppressedDiagnostics = reportSuppressedDiagnostics; LogPerformanceInfo = logPerformanceInfo; GetTelemetryInfo = getTelemetryInfo; DocumentId = documentId; diff --git a/src/Features/Core/Portable/Diagnostics/IDiagnosticAnalyzerService.cs b/src/Features/Core/Portable/Diagnostics/IDiagnosticAnalyzerService.cs index 04ffcf80cab7a..ae24d455143c2 100644 --- a/src/Features/Core/Portable/Diagnostics/IDiagnosticAnalyzerService.cs +++ b/src/Features/Core/Portable/Diagnostics/IDiagnosticAnalyzerService.cs @@ -33,7 +33,6 @@ internal interface IDiagnosticAnalyzerService /// Workspace for the document/project/solution to compute diagnostics for. /// Optional project to scope the returned diagnostics. /// Optional document to scope the returned diagnostics. - /// Indicates if diagnostics suppressed in source via pragmas and SuppressMessageAttributes should be returned. /// /// Indicates if local document diagnostics must be returned. /// Local diagnostics are the ones that are reported by analyzers on the same file for which the callback was received @@ -46,7 +45,7 @@ internal interface IDiagnosticAnalyzerService /// complete set of non-local document diagnostics. /// /// Cancellation token. - Task> GetCachedDiagnosticsAsync(Workspace workspace, ProjectId? projectId, DocumentId? documentId, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); + Task> GetCachedDiagnosticsAsync(Workspace workspace, ProjectId? projectId, DocumentId? documentId, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); /// /// Force analyzes the given project by running all applicable analyzers on the project and caching the reported analyzer diagnostics. @@ -54,29 +53,29 @@ internal interface IDiagnosticAnalyzerService Task ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken); /// - /// Get diagnostics of the given diagnostic ids and/or analyzers from the given solution. all diagnostics returned should be up-to-date with respect to the given solution. - /// Note that for project case, this method returns diagnostics from all project documents as well. Use - /// if you want to fetch only project diagnostics without source locations. + /// Get diagnostics of the given diagnostic ids and/or analyzers from the given solution. all diagnostics returned + /// should be up-to-date with respect to the given solution. Note that for project case, this method returns + /// diagnostics from all project documents as well. Use if you want + /// to fetch only project diagnostics without source locations. /// /// Solution to fetch the diagnostics for. /// Optional project to scope the returned diagnostics. /// Optional document to scope the returned diagnostics. /// Optional set of diagnostic IDs to scope the returned diagnostics. /// Option callback to filter out analyzers to execute for computing diagnostics. - /// Indicates if diagnostics suppressed in source via pragmas and SuppressMessageAttributes should be returned. /// /// Indicates if local document diagnostics must be returned. /// Local diagnostics are the ones that are reported by analyzers on the same file for which the callback was received /// and hence can be computed by analyzing a single file in isolation. /// /// - /// Indicates if non-local document diagnostics must be returned. - /// Non-local diagnostics are the ones reported by analyzers either at compilation end callback OR - /// in a different file from which the callback was made. Entire project must be analyzed to get the - /// complete set of non-local document diagnostics. + /// Indicates if non-local document diagnostics must be returned. Non-local diagnostics are the ones reported by + /// analyzers either at compilation end callback OR in a different file from which the callback was made. Entire + /// project must be analyzed to get the complete set of non-local document diagnostics. /// /// Cancellation token. - Task> GetDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocumentIds, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); + Task> GetDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocumentIds, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); /// /// Get project diagnostics (diagnostics with no source location) of the given diagnostic ids and/or analyzers from @@ -88,14 +87,13 @@ internal interface IDiagnosticAnalyzerService /// Optional project to scope the returned diagnostics. /// Optional set of diagnostic IDs to scope the returned diagnostics. /// Option callback to filter out analyzers to execute for computing diagnostics. - /// Indicates if diagnostics suppressed in source via SuppressMessageAttributes should be returned. /// /// Indicates if non-local document diagnostics must be returned. /// Non-local diagnostics are the ones reported by analyzers either at compilation end callback. /// Entire project must be analyzed to get the complete set of non-local diagnostics. /// /// Cancellation token. - Task> GetProjectDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeSuppressedDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); + Task> GetProjectDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); /// /// Return up to date diagnostics for the given span for the document @@ -108,7 +106,6 @@ internal interface IDiagnosticAnalyzerService Task> GetDiagnosticsForSpanAsync( TextDocument document, TextSpan? range, Func? shouldIncludeDiagnostic, bool includeCompilerDiagnostics, - bool includeSuppressedDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, DiagnosticKind diagnosticKind, bool isExplicit, @@ -123,9 +120,16 @@ internal static class IDiagnosticAnalyzerServiceExtensions /// This can be expensive since it is force analyzing diagnostics if it doesn't have up-to-date one yet. /// /// - public static Task> GetDiagnosticsForSpanAsync(this IDiagnosticAnalyzerService service, + /// + /// Only returns non-suppressed diagnostics. + /// + public static async Task> GetDiagnosticsForSpanAsync(this IDiagnosticAnalyzerService service, TextDocument document, TextSpan? range, CancellationToken cancellationToken) - => service.GetDiagnosticsForSpanAsync(document, range, DiagnosticKind.All, includeSuppressedDiagnostics: false, cancellationToken); + { + var result = await service.GetDiagnosticsForSpanAsync( + document, range, DiagnosticKind.All, cancellationToken).ConfigureAwait(false); + return result.WhereAsArray(d => !d.IsSuppressed); + } /// /// Return up to date diagnostics of the given for the given @@ -135,9 +139,10 @@ public static Task> GetDiagnosticsForSpanAsync(th /// /// public static Task> GetDiagnosticsForSpanAsync(this IDiagnosticAnalyzerService service, - TextDocument document, TextSpan? range, DiagnosticKind diagnosticKind, bool includeSuppressedDiagnostics, CancellationToken cancellationToken) - => service.GetDiagnosticsForSpanAsync(document, range, - diagnosticId: null, includeSuppressedDiagnostics, + TextDocument document, TextSpan? range, DiagnosticKind diagnosticKind, CancellationToken cancellationToken) + => service.GetDiagnosticsForSpanAsync( + document, range, + diagnosticId: null, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), diagnosticKind, isExplicit: false, cancellationToken); @@ -151,7 +156,6 @@ public static Task> GetDiagnosticsForSpanAsync(th /// public static Task> GetDiagnosticsForSpanAsync(this IDiagnosticAnalyzerService service, TextDocument document, TextSpan? range, string? diagnosticId, - bool includeSuppressedDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, DiagnosticKind diagnosticKind, bool isExplicit, @@ -159,15 +163,15 @@ public static Task> GetDiagnosticsForSpanAsync(th { Func? shouldIncludeDiagnostic = diagnosticId != null ? id => id == diagnosticId : null; return service.GetDiagnosticsForSpanAsync(document, range, shouldIncludeDiagnostic, - includeCompilerDiagnostics: true, includeSuppressedDiagnostics, priorityProvider, + includeCompilerDiagnostics: true, priorityProvider, diagnosticKind, isExplicit, cancellationToken); } public static Task> GetDiagnosticsForIdsAsync( - this IDiagnosticAnalyzerService service, Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + this IDiagnosticAnalyzerService service, Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) { return service.GetDiagnosticsForIdsAsync( solution, projectId, documentId, diagnosticIds, shouldIncludeAnalyzer, getDocumentIds: null, - includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); + includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); } } diff --git a/src/LanguageServer/Protocol.TestUtilities/Diagnostics/TestDiagnosticAnalyzerDriver.cs b/src/LanguageServer/Protocol.TestUtilities/Diagnostics/TestDiagnosticAnalyzerDriver.cs index 8627649d954d6..04e23cd3ff207 100644 --- a/src/LanguageServer/Protocol.TestUtilities/Diagnostics/TestDiagnosticAnalyzerDriver.cs +++ b/src/LanguageServer/Protocol.TestUtilities/Diagnostics/TestDiagnosticAnalyzerDriver.cs @@ -50,7 +50,8 @@ private async Task> GetDiagnosticsAsync( var text = await document.GetTextAsync().ConfigureAwait(false); var dxs = await _diagnosticAnalyzerService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, document.Id, diagnosticIds: null, shouldIncludeAnalyzer: null, - _includeSuppressedDiagnostics, includeLocalDocumentDiagnostics: true, _includeNonLocalDocumentDiagnostics, CancellationToken.None); + includeLocalDocumentDiagnostics: true, _includeNonLocalDocumentDiagnostics, CancellationToken.None); + dxs = dxs.WhereAsArray(d => _includeSuppressedDiagnostics || !d.IsSuppressed); documentDiagnostics = await CodeAnalysis.Diagnostics.Extensions.ToDiagnosticsAsync( filterSpan is null ? dxs.Where(d => d.DataLocation.DocumentId != null) @@ -63,7 +64,8 @@ filterSpan is null { var dxs = await _diagnosticAnalyzerService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId: null, diagnosticIds: null, shouldIncludeAnalyzer: null, - _includeSuppressedDiagnostics, includeLocalDocumentDiagnostics: true, _includeNonLocalDocumentDiagnostics, CancellationToken.None); + includeLocalDocumentDiagnostics: true, _includeNonLocalDocumentDiagnostics, CancellationToken.None); + dxs = dxs.WhereAsArray(d => _includeSuppressedDiagnostics || !d.IsSuppressed); projectDiagnostics = await CodeAnalysis.Diagnostics.Extensions.ToDiagnosticsAsync(dxs.Where(d => d.DocumentId is null), project, CancellationToken.None); } diff --git a/src/LanguageServer/Protocol/Features/CodeCleanup/AbstractCodeCleanupService.cs b/src/LanguageServer/Protocol/Features/CodeCleanup/AbstractCodeCleanupService.cs index 0c3b268d504a4..6f546fa963e47 100644 --- a/src/LanguageServer/Protocol/Features/CodeCleanup/AbstractCodeCleanupService.cs +++ b/src/LanguageServer/Protocol/Features/CodeCleanup/AbstractCodeCleanupService.cs @@ -200,12 +200,15 @@ private async Task ApplyCodeFixesForSpecificDiagnosticIdAsync( var range = new TextSpan(0, tree.Length); // Compute diagnostics for everything that is not an IDE analyzer - var diagnostics = (await _diagnosticService.GetDiagnosticsForSpanAsync(document, range, + var diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync(document, range, shouldIncludeDiagnostic: static diagnosticId => !(IDEDiagnosticIdToOptionMappingHelper.IsKnownIDEDiagnosticId(diagnosticId)), - includeCompilerDiagnostics: true, includeSuppressedDiagnostics: false, + includeCompilerDiagnostics: true, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), DiagnosticKind.All, isExplicit: false, - cancellationToken).ConfigureAwait(false)); + cancellationToken).ConfigureAwait(false); + + // We don't want code cleanup automatically cleaning suppressed diagnostics. + diagnostics = diagnostics.WhereAsArray(d => !d.IsSuppressed); // ensure more than just known diagnostics were returned if (!diagnostics.Any()) diff --git a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs index b58a082f23e67..98da7ff2b74e6 100644 --- a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs +++ b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs @@ -20,7 +20,6 @@ private sealed class FixAllDiagnosticProvider : FixAllContext.SpanBasedDiagnosti { private readonly IDiagnosticAnalyzerService _diagnosticService; private readonly ImmutableHashSet? _diagnosticIds; - private readonly bool _includeSuppressedDiagnostics; public FixAllDiagnosticProvider(IDiagnosticAnalyzerService diagnosticService, ImmutableHashSet diagnosticIds) { @@ -29,22 +28,14 @@ public FixAllDiagnosticProvider(IDiagnosticAnalyzerService diagnosticService, Im // When computing FixAll for unnecessary pragma suppression diagnostic, // we need to include suppressed diagnostics, as well as reported compiler and analyzer diagnostics. // A null value for '_diagnosticIds' ensures the latter. - if (diagnosticIds.Contains(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId)) - { - _diagnosticIds = null; - _includeSuppressedDiagnostics = true; - } - else - { - _diagnosticIds = diagnosticIds; - _includeSuppressedDiagnostics = false; - } + _diagnosticIds = diagnosticIds.Contains(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId) + ? null : diagnosticIds; } public override async Task> GetDocumentDiagnosticsAsync(Document document, CancellationToken cancellationToken) { var solution = document.Project.Solution; - var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(solution, projectId: null, document.Id, _diagnosticIds, shouldIncludeAnalyzer: null, _includeSuppressedDiagnostics, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(solution, projectId: null, document.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); Contract.ThrowIfFalse(diagnostics.All(d => d.DocumentId != null)); return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false); } @@ -53,7 +44,7 @@ public override async Task> GetDocumentSpanDiagnosticsAs { bool shouldIncludeDiagnostic(string id) => _diagnosticIds == null || _diagnosticIds.Contains(id); var diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync(document, fixAllSpan, shouldIncludeDiagnostic, - includeCompilerDiagnostics: true, _includeSuppressedDiagnostics, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), + includeCompilerDiagnostics: true, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), DiagnosticKind.All, isExplicit: false, cancellationToken).ConfigureAwait(false); Contract.ThrowIfFalse(diagnostics.All(d => d.DocumentId != null)); return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false); @@ -62,14 +53,14 @@ public override async Task> GetDocumentSpanDiagnosticsAs public override async Task> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) { // Get all diagnostics for the entire project, including document diagnostics. - var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId: null, _diagnosticIds, shouldIncludeAnalyzer: null, _includeSuppressedDiagnostics, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId: null, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); return await diagnostics.ToDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false); } public override async Task> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) { // Get all no-location diagnostics for the project, doesn't include document diagnostics. - var diagnostics = await _diagnosticService.GetProjectDiagnosticsForIdsAsync(project.Solution, project.Id, _diagnosticIds, shouldIncludeAnalyzer: null, _includeSuppressedDiagnostics, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = await _diagnosticService.GetProjectDiagnosticsForIdsAsync(project.Solution, project.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); Contract.ThrowIfFalse(diagnostics.All(d => d.DocumentId == null)); return await diagnostics.ToDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false); } diff --git a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs index 10f077b002883..90c924e03d4bd 100644 --- a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs +++ b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs @@ -109,7 +109,12 @@ public CodeFixService( { allDiagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync( document, range, GetShouldIncludeDiagnosticPredicate(document, priorityProvider), - includeCompilerDiagnostics: true, includeSuppressedDiagnostics: false, priorityProvider, DiagnosticKind.All, isExplicit: false, cancellationToken).ConfigureAwait(false); + includeCompilerDiagnostics: true, priorityProvider, DiagnosticKind.All, isExplicit: false, cancellationToken).ConfigureAwait(false); + + // NOTE(cyrusn): We do not include suppressed diagnostics here as they are effectively hidden from the + // user in the editor. As far as the user is concerned, there is no squiggle for it and no lightbulb + // entries either. + allDiagnostics = allDiagnostics.WhereAsArray(d => !d.IsSuppressed); } var copilotDiagnostics = await GetCopilotDiagnosticsAsync(document, range, priorityProvider.Priority, cancellationToken).ConfigureAwait(false); @@ -194,8 +199,7 @@ public async IAsyncEnumerable StreamFixesAsync( { diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync( document, range, GetShouldIncludeDiagnosticPredicate(document, priorityProvider), - includeCompilerDiagnostics: true, includeSuppressedDiagnostics: includeSuppressionFixes, priorityProvider, - DiagnosticKind.All, isExplicit: true, cancellationToken).ConfigureAwait(false); + includeCompilerDiagnostics: true, priorityProvider, DiagnosticKind.All, isExplicit: true, cancellationToken).ConfigureAwait(false); } var copilotDiagnostics = await GetCopilotDiagnosticsAsync(document, range, priorityProvider.Priority, cancellationToken).ConfigureAwait(false); @@ -292,8 +296,13 @@ private static SortedDictionary> ConvertToMap( using (TelemetryLogging.LogBlockTimeAggregatedHistogram(FunctionId.CodeFix_Summary, $"{nameof(GetDocumentFixAllForIdInSpanAsync)}.{nameof(_diagnosticService.GetDiagnosticsForSpanAsync)}")) { diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync( - document, range, diagnosticId, includeSuppressedDiagnostics: false, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), + document, range, diagnosticId, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), DiagnosticKind.All, isExplicit: false, cancellationToken).ConfigureAwait(false); + + // NOTE(cyrusn): We do not include suppressed diagnostics here as they are effectively hidden from the + // user in the editor. As far as the user is concerned, there is no squiggle for it and no lightbulb + // entries either. + diagnostics = diagnostics.WhereAsArray(d => !d.IsSuppressed); } diagnostics = diagnostics.WhereAsArray(d => d.Severity.IsMoreSevereThanOrEqualTo(minimumSeverity)); diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/DiagnosticAnalyzerService.cs b/src/LanguageServer/Protocol/Features/Diagnostics/DiagnosticAnalyzerService.cs index 2ec8ee686304b..fbef8d15b4f76 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/DiagnosticAnalyzerService.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/DiagnosticAnalyzerService.cs @@ -6,7 +6,6 @@ using System.Collections.Generic; using System.Collections.Immutable; using System.Composition; -using System.Linq; using System.Runtime.CompilerServices; using System.Threading; using System.Threading.Tasks; @@ -15,12 +14,10 @@ using Microsoft.CodeAnalysis.Diagnostics.EngineV2; using Microsoft.CodeAnalysis.Host.Mef; using Microsoft.CodeAnalysis.Options; -using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Shared.TestHooks; using Microsoft.CodeAnalysis.SolutionCrawler; using Microsoft.CodeAnalysis.Text; using Microsoft.VisualStudio.Threading; -using Roslyn.Utilities; namespace Microsoft.CodeAnalysis.Diagnostics { @@ -81,7 +78,6 @@ public async Task> GetDiagnosticsForSpanAsync( TextSpan? range, Func? shouldIncludeDiagnostic, bool includeCompilerDiagnostics, - bool includeSuppressedDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, DiagnosticKind diagnosticKinds, bool isExplicit, @@ -94,14 +90,14 @@ public async Task> GetDiagnosticsForSpanAsync( priorityProvider ??= new DefaultCodeActionRequestPriorityProvider(); return await analyzer.GetDiagnosticsForSpanAsync( - document, range, shouldIncludeDiagnostic, includeSuppressedDiagnostics, includeCompilerDiagnostics, + document, range, shouldIncludeDiagnostic, includeCompilerDiagnostics, priorityProvider, diagnosticKinds, isExplicit, cancellationToken).ConfigureAwait(false); } - public Task> GetCachedDiagnosticsAsync(Workspace workspace, ProjectId? projectId, DocumentId? documentId, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + public Task> GetCachedDiagnosticsAsync(Workspace workspace, ProjectId? projectId, DocumentId? documentId, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) { var analyzer = CreateIncrementalAnalyzer(workspace); - return analyzer.GetCachedDiagnosticsAsync(workspace.CurrentSolution, projectId, documentId, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); + return analyzer.GetCachedDiagnosticsAsync(workspace.CurrentSolution, projectId, documentId, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); } public async Task ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken) @@ -111,19 +107,19 @@ public async Task ForceAnalyzeProjectAsync(Project project, CancellationToken ca } public Task> GetDiagnosticsForIdsAsync( - Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) { var analyzer = CreateIncrementalAnalyzer(solution.Workspace); - return analyzer.GetDiagnosticsForIdsAsync(solution, projectId, documentId, diagnosticIds, shouldIncludeAnalyzer, getDocuments, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); + return analyzer.GetDiagnosticsForIdsAsync(solution, projectId, documentId, diagnosticIds, shouldIncludeAnalyzer, getDocuments, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); } public Task> GetProjectDiagnosticsForIdsAsync( Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, - Func? shouldIncludeAnalyzer, bool includeSuppressedDiagnostics, + Func? shouldIncludeAnalyzer, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) { var analyzer = CreateIncrementalAnalyzer(solution.Workspace); - return analyzer.GetProjectDiagnosticsForIdsAsync(solution, projectId, diagnosticIds, shouldIncludeAnalyzer, includeSuppressedDiagnostics, includeNonLocalDocumentDiagnostics, cancellationToken); + return analyzer.GetProjectDiagnosticsForIdsAsync(solution, projectId, diagnosticIds, shouldIncludeAnalyzer, includeNonLocalDocumentDiagnostics, cancellationToken); } } } diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor_Helpers.cs b/src/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor_Helpers.cs index 41dade51c947f..eecd062437cec 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor_Helpers.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor_Helpers.cs @@ -132,7 +132,6 @@ static string GetLanguageSpecificId(string? language, string noLanguageId, strin Project project, ImmutableArray projectAnalyzers, ImmutableArray hostAnalyzers, - bool includeSuppressedDiagnostics, bool crashOnAnalyzerException, CancellationToken cancellationToken) { @@ -167,14 +166,14 @@ static string GetLanguageSpecificId(string? language, string noLanguageId, strin analyzerExceptionFilter: GetAnalyzerExceptionFilter(), concurrentAnalysis: false, logAnalyzerExecutionTime: true, - reportSuppressedDiagnostics: includeSuppressedDiagnostics); + reportSuppressedDiagnostics: true); var hostAnalyzerOptions = new CompilationWithAnalyzersOptions( options: project.HostAnalyzerOptions, onAnalyzerException: null, analyzerExceptionFilter: GetAnalyzerExceptionFilter(), concurrentAnalysis: false, logAnalyzerExecutionTime: true, - reportSuppressedDiagnostics: includeSuppressedDiagnostics); + reportSuppressedDiagnostics: true); // Create driver that holds onto compilation and associated analyzers return new CompilationWithAnalyzersPair( diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs index 7ff7a1c34e532..9775aef42f602 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs @@ -6,11 +6,10 @@ using System.Threading; using System.Threading.Tasks; -namespace Microsoft.CodeAnalysis.Diagnostics.EngineV2 +namespace Microsoft.CodeAnalysis.Diagnostics.EngineV2; + +internal partial class DiagnosticIncrementalAnalyzer { - internal partial class DiagnosticIncrementalAnalyzer - { - private static Task CreateCompilationWithAnalyzersAsync(Project project, ImmutableArray stateSets, bool includeSuppressedDiagnostics, bool crashOnAnalyzerException, CancellationToken cancellationToken) - => DocumentAnalysisExecutor.CreateCompilationWithAnalyzersAsync(project, stateSets.SelectAsArray(s => !s.IsHostAnalyzer, s => s.Analyzer), stateSets.SelectAsArray(s => s.IsHostAnalyzer, s => s.Analyzer), includeSuppressedDiagnostics, crashOnAnalyzerException, cancellationToken); - } + private static Task CreateCompilationWithAnalyzersAsync(Project project, ImmutableArray stateSets, bool crashOnAnalyzerException, CancellationToken cancellationToken) + => DocumentAnalysisExecutor.CreateCompilationWithAnalyzersAsync(project, stateSets.SelectAsArray(s => !s.IsHostAnalyzer, s => s.Analyzer), stateSets.SelectAsArray(s => s.IsHostAnalyzer, s => s.Analyzer), crashOnAnalyzerException, cancellationToken); } diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs index dd0d6746da3da..82f948660ab2d 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs @@ -144,7 +144,6 @@ await DocumentAnalysisExecutor.CreateCompilationWithAnalyzersAsync( project, projectAnalyzersToRun, hostAnalyzersToRun, - compilationWithAnalyzers.ReportSuppressedDiagnostics, AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs index 125475d2ccc85..3fced9e7cdeff 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs @@ -142,8 +142,7 @@ private async Task> GetCachedDiagnosticsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) - => new IdeCachedDiagnosticGetter(this, solution, projectId, documentId, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics).GetDiagnosticsAsync(cancellationToken); + public Task> GetCachedDiagnosticsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + => new IdeCachedDiagnosticGetter(this, solution, projectId, documentId, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics).GetDiagnosticsAsync(cancellationToken); - public Task> GetDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) - => new IdeLatestDiagnosticGetter(this, solution, projectId, documentId, diagnosticIds, shouldIncludeAnalyzer, getDocuments, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics).GetDiagnosticsAsync(cancellationToken); + public Task> GetDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, DocumentId? documentId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + => new IdeLatestDiagnosticGetter(this, solution, projectId, documentId, diagnosticIds, shouldIncludeAnalyzer, getDocuments, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics).GetDiagnosticsAsync(cancellationToken); - public Task> GetProjectDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeSuppressedDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) - => new IdeLatestDiagnosticGetter(this, solution, projectId, documentId: null, diagnosticIds, shouldIncludeAnalyzer, getDocuments: null, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics: false, includeNonLocalDocumentDiagnostics).GetProjectDiagnosticsAsync(cancellationToken); + public Task> GetProjectDiagnosticsForIdsAsync(Solution solution, ProjectId? projectId, ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) + => new IdeLatestDiagnosticGetter(this, solution, projectId, documentId: null, diagnosticIds, shouldIncludeAnalyzer, getDocuments: null, includeLocalDocumentDiagnostics: false, includeNonLocalDocumentDiagnostics).GetProjectDiagnosticsAsync(cancellationToken); private abstract class DiagnosticGetter( DiagnosticIncrementalAnalyzer owner, @@ -30,7 +30,6 @@ private abstract class DiagnosticGetter( ProjectId? projectId, DocumentId? documentId, Func>? getDocuments, - bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics) { @@ -39,7 +38,6 @@ private abstract class DiagnosticGetter( protected readonly Solution Solution = solution; protected readonly ProjectId? ProjectId = projectId ?? documentId?.ProjectId; protected readonly DocumentId? DocumentId = documentId; - protected readonly bool IncludeSuppressedDiagnostics = includeSuppressedDiagnostics; protected readonly bool IncludeLocalDocumentDiagnostics = includeLocalDocumentDiagnostics; protected readonly bool IncludeNonLocalDocumentDiagnostics = includeNonLocalDocumentDiagnostics; @@ -90,13 +88,10 @@ protected void InvokeCallback(Action callback, ImmutableArray IncludeSuppressedDiagnostics || !diagnostic.IsSuppressed; } private sealed class IdeCachedDiagnosticGetter( @@ -104,10 +99,9 @@ private sealed class IdeCachedDiagnosticGetter( Solution solution, ProjectId? projectId, DocumentId? documentId, - bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics) : DiagnosticGetter( - owner, solution, projectId, documentId, getDocuments: null, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics) + owner, solution, projectId, documentId, getDocuments: null, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics) { protected override async Task ProduceDiagnosticsAsync( Project project, IReadOnlyList documentIds, bool includeProjectNonLocalResult, @@ -152,7 +146,7 @@ public async Task> GetSpecificDiagnosticsAsync(Di var diagnostics = await GetDiagnosticsAsync(stateSet, project, DocumentId, analysisKind, cancellationToken).ConfigureAwait(false); - return IncludeSuppressedDiagnostics ? diagnostics : diagnostics.WhereAsArray(d => !d.IsSuppressed); + return diagnostics; } private static async Task> GetDiagnosticsAsync(StateSet stateSet, Project project, DocumentId? documentId, AnalysisKind kind, CancellationToken cancellationToken) @@ -207,10 +201,9 @@ private sealed class IdeLatestDiagnosticGetter( ImmutableHashSet? diagnosticIds, Func? shouldIncludeAnalyzer, Func>? getDocuments, - bool includeSuppressedDiagnostics, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics) : DiagnosticGetter( - owner, solution, projectId, documentId, getDocuments, includeSuppressedDiagnostics, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics) + owner, solution, projectId, documentId, getDocuments, includeLocalDocumentDiagnostics, includeNonLocalDocumentDiagnostics) { private readonly ImmutableHashSet? _diagnosticIds = diagnosticIds; private readonly Func? _shouldIncludeAnalyzer = shouldIncludeAnalyzer; @@ -242,7 +235,7 @@ protected override async Task ProduceDiagnosticsAsync( var stateSets = stateSetsForProject.Where(s => ShouldIncludeStateSet(project, s)).ToImmutableArrayOrEmpty(); // unlike the suppressed (disabled) analyzer, we will include hidden diagnostic only analyzers here. - var compilation = await CreateCompilationWithAnalyzersAsync(project, stateSets, IncludeSuppressedDiagnostics, Owner.AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); + var compilation = await CreateCompilationWithAnalyzersAsync(project, stateSets, Owner.AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); var result = await Owner.GetProjectAnalysisDataAsync(compilation, project, stateSets, cancellationToken).ConfigureAwait(false); diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs index b7a0092f237d2..2f48d82960e42 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs @@ -26,7 +26,6 @@ public async Task> GetDiagnosticsForSpanAsync( TextDocument document, TextSpan? range, Func? shouldIncludeDiagnostic, - bool includeSuppressedDiagnostics, bool includeCompilerDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, DiagnosticKind diagnosticKinds, @@ -36,7 +35,7 @@ public async Task> GetDiagnosticsForSpanAsync( using var _ = ArrayBuilder.GetInstance(out var list); var getter = await LatestDiagnosticsForSpanGetter.CreateAsync( - this, document, range, includeSuppressedDiagnostics, includeCompilerDiagnostics, + this, document, range, includeCompilerDiagnostics, priorityProvider, shouldIncludeDiagnostic, diagnosticKinds, isExplicit, cancellationToken).ConfigureAwait(false); await getter.GetAsync(list, cancellationToken).ConfigureAwait(false); @@ -61,7 +60,6 @@ private sealed class LatestDiagnosticsForSpanGetter private readonly CompilationWithAnalyzersPair? _compilationWithAnalyzers; private readonly TextSpan? _range; - private readonly bool _includeSuppressedDiagnostics; private readonly ICodeActionRequestPriorityProvider _priorityProvider; private readonly Func? _shouldIncludeDiagnostic; private readonly bool _includeCompilerDiagnostics; @@ -76,7 +74,6 @@ public static async Task CreateAsync( DiagnosticIncrementalAnalyzer owner, TextDocument document, TextSpan? range, - bool includeSuppressedDiagnostics, bool includeCompilerDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, Func? shouldIncludeDiagnostic, @@ -99,7 +96,7 @@ public static async Task CreateAsync( // We log performance info when we are computing diagnostics for a span var logPerformanceInfo = range.HasValue; - var compilationWithAnalyzers = await GetOrCreateCompilationWithAnalyzersAsync(document.Project, stateSets, includeSuppressedDiagnostics, owner.AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); + var compilationWithAnalyzers = await GetOrCreateCompilationWithAnalyzersAsync(document.Project, stateSets, owner.AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); // If we are computing full document diagnostics, we will attempt to perform incremental // member edit analysis. This analysis is currently only enabled with LSP pull diagnostics. @@ -108,14 +105,12 @@ public static async Task CreateAsync( return new LatestDiagnosticsForSpanGetter( owner, compilationWithAnalyzers, document, text, stateSets, shouldIncludeDiagnostic, includeCompilerDiagnostics, - range, includeSuppressedDiagnostics, priorityProvider, - isExplicit, logPerformanceInfo, incrementalAnalysis, diagnosticKinds); + range, priorityProvider, isExplicit, logPerformanceInfo, incrementalAnalysis, diagnosticKinds); } private static async Task GetOrCreateCompilationWithAnalyzersAsync( Project project, ImmutableArray stateSets, - bool includeSuppressedDiagnostics, bool crashOnAnalyzerException, CancellationToken cancellationToken) { @@ -133,7 +128,7 @@ public static async Task CreateAsync( } } - var compilationWithAnalyzers = await CreateCompilationWithAnalyzersAsync(project, stateSets, includeSuppressedDiagnostics, crashOnAnalyzerException, cancellationToken).ConfigureAwait(false); + var compilationWithAnalyzers = await CreateCompilationWithAnalyzersAsync(project, stateSets, crashOnAnalyzerException, cancellationToken).ConfigureAwait(false); s_lastProjectAndCompilationWithAnalyzers.SetTarget(new ProjectAndCompilationWithAnalyzers(project, compilationWithAnalyzers)); return compilationWithAnalyzers; @@ -160,7 +155,6 @@ private LatestDiagnosticsForSpanGetter( Func? shouldIncludeDiagnostic, bool includeCompilerDiagnostics, TextSpan? range, - bool includeSuppressedDiagnostics, ICodeActionRequestPriorityProvider priorityProvider, bool isExplicit, bool logPerformanceInfo, @@ -175,7 +169,6 @@ private LatestDiagnosticsForSpanGetter( _shouldIncludeDiagnostic = shouldIncludeDiagnostic; _includeCompilerDiagnostics = includeCompilerDiagnostics; _range = range; - _includeSuppressedDiagnostics = includeSuppressedDiagnostics; _priorityProvider = priorityProvider; _isExplicit = isExplicit; _logPerformanceInfo = logPerformanceInfo; @@ -531,7 +524,6 @@ private bool ShouldInclude(DiagnosticData diagnostic) { return diagnostic.DocumentId == _document.Id && (_range == null || _range.Value.IntersectsWith(diagnostic.DataLocation.UnmappedFileSpan.GetClampedTextSpan(_text))) - && (_includeSuppressedDiagnostics || !diagnostic.IsSuppressed) && (_includeCompilerDiagnostics || !diagnostic.CustomTags.Any(static t => t is WellKnownDiagnosticTags.Compiler)) && (_shouldIncludeDiagnostic == null || _shouldIncludeDiagnostic(diagnostic.Id)); } diff --git a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs index dbba786e56472..93ba079476f40 100644 --- a/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs +++ b/src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs @@ -32,7 +32,7 @@ public async Task> ForceAnalyzeProjectAsync(Proje CompilationWithAnalyzersPair? compilationWithAnalyzers = null; compilationWithAnalyzers = await DocumentAnalysisExecutor.CreateCompilationWithAnalyzersAsync( - project, activeProjectAnalyzers, activeHostAnalyzers, includeSuppressedDiagnostics: true, AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); + project, activeProjectAnalyzers, activeHostAnalyzers, AnalyzerService.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); var result = await GetProjectAnalysisDataAsync(compilationWithAnalyzers, project, stateSets, cancellationToken).ConfigureAwait(false); diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractProjectDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractProjectDiagnosticSource.cs index ac49b0a9da7c6..0c122523e9b86 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractProjectDiagnosticSource.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractProjectDiagnosticSource.cs @@ -50,8 +50,12 @@ public override async Task> GetDiagnosticsAsync( // we're passing in. If information is already cached for that snapshot, it will be returned. Otherwise, // it will be computed on demand. Because it is always accurate as per this snapshot, all spans are correct // and do not need to be adjusted. - return await diagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync(Project.Solution, Project.Id, - diagnosticIds: null, shouldIncludeAnalyzer, includeSuppressedDiagnostics: false, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = await diagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync(Project.Solution, Project.Id, + diagnosticIds: null, shouldIncludeAnalyzer, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + + // TODO(cyrusn): In the future we could consider reporting these, but with a flag on the diagnostic mentioning + // that it is suppressed and should be hidden from the task list by default. + return diagnostics.WhereAsArray(d => !d.IsSuppressed); } } diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs index 8d65f234de69b..fc588c1916582 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs @@ -78,9 +78,10 @@ AsyncLazy> GetLazyDiagnostics() diagnosticIds: null, shouldIncludeAnalyzer, // Ensure we compute and return diagnostics for both the normal docs and the additional docs in this project. static (project, _) => [.. project.DocumentIds.Concat(project.AdditionalDocumentIds)], - includeSuppressedDiagnostics: false, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false); - return allDiagnostics.Where(d => d.DocumentId != null).ToLookup(d => d.DocumentId!); + + // TODO(cyrusn): Should we be filtering out suppressed diagnostics here? + return allDiagnostics.Where(d => !d.IsSuppressed && d.DocumentId != null).ToLookup(d => d.DocumentId!); })); } } diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/DocumentDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/DocumentDiagnosticSource.cs index e9a5ad49650bf..34203462a17d3 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/DocumentDiagnosticSource.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/DocumentDiagnosticSource.cs @@ -27,9 +27,10 @@ public override async Task> GetDiagnosticsAsync( // We call GetDiagnosticsForSpanAsync here instead of GetDiagnosticsForIdsAsync as it has faster perf // characteristics. GetDiagnosticsForIdsAsync runs analyzers against the entire compilation whereas // GetDiagnosticsForSpanAsync will only run analyzers against the request document. - // Also ensure we pass in "includeSuppressedDiagnostics = true" for unnecessary suppressions to be reported. var allSpanDiagnostics = await diagnosticAnalyzerService.GetDiagnosticsForSpanAsync( - Document, range: null, diagnosticKind: this.DiagnosticKind, includeSuppressedDiagnostics: true, cancellationToken: cancellationToken).ConfigureAwait(false); + Document, range: null, diagnosticKind: this.DiagnosticKind, cancellationToken).ConfigureAwait(false); + + // Note: we do not filter our suppressed diagnostics we we want unnecessary suppressions to be reported. // Add cached Copilot diagnostics when computing analyzer semantic diagnostics. // TODO: move to a separate diagnostic source. https://github.com/dotnet/roslyn/issues/72896 diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/NonLocalDocumentDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/NonLocalDocumentDiagnosticSource.cs index d370f15240a60..b2a168f48a928 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/NonLocalDocumentDiagnosticSource.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/NonLocalDocumentDiagnosticSource.cs @@ -22,11 +22,16 @@ public override async Task> GetDiagnosticsAsync( RequestContext context, CancellationToken cancellationToken) { - // We call GetDiagnosticsForIdsAsync as we want to ensure we get the full set of non-local diagnostics for this document - // including those reported as a compilation end diagnostic. These are not included in document pull (uses GetDiagnosticsForSpan) due to cost. - return await diagnosticAnalyzerService.GetDiagnosticsForIdsAsync( + // We call GetDiagnosticsForIdsAsync as we want to ensure we get the full set of non-local diagnostics for this + // document including those reported as a compilation end diagnostic. These are not included in document pull + // (uses GetDiagnosticsForSpan) due to cost. + var diagnostics = await diagnosticAnalyzerService.GetDiagnosticsForIdsAsync( Document.Project.Solution, Document.Project.Id, Document.Id, - diagnosticIds: null, _shouldIncludeAnalyzer, includeSuppressedDiagnostics: false, + diagnosticIds: null, _shouldIncludeAnalyzer, includeLocalDocumentDiagnostics: false, includeNonLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false); + + // TODO(cyrusn): In the future we could consider reporting these, but with a flag on the diagnostic mentioning + // that it is suppressed and should be hidden from the task list by default. + return diagnostics.WhereAsArray(d => !d.IsSuppressed); } } diff --git a/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs b/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs index 23cd3cc49e643..083a2fc3c2efa 100644 --- a/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs +++ b/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs @@ -487,7 +487,7 @@ private async Task>> Ge var uniqueDiagnosticIds = group.SelectMany(kvp => kvp.Value.Select(d => d.Id)).ToImmutableHashSet(); var latestProjectDiagnostics = (await _diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId: null, - diagnosticIds: uniqueDiagnosticIds, shouldIncludeAnalyzer: null, includeSuppressedDiagnostics: true, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, cancellationToken) + diagnosticIds: uniqueDiagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, cancellationToken) .ConfigureAwait(false)).Where(IsDocumentDiagnostic); latestDocumentDiagnosticsMap.Clear(); @@ -577,7 +577,7 @@ private async Task>> Get var uniqueDiagnosticIds = diagnostics.Select(d => d.Id).ToImmutableHashSet(); var latestDiagnosticsFromDiagnosticService = (await _diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId: null, - diagnosticIds: uniqueDiagnosticIds, shouldIncludeAnalyzer: null, includeSuppressedDiagnostics: true, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, cancellationToken) + diagnosticIds: uniqueDiagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, cancellationToken) .ConfigureAwait(false)); latestDiagnosticsToFix.Clear(); diff --git a/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb b/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb index a0cd2d9fd0726..71428bfca2712 100644 --- a/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb +++ b/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb @@ -316,19 +316,19 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics Public Sub RequestDiagnosticRefresh() Implements IDiagnosticAnalyzerService.RequestDiagnosticRefresh End Sub - Public Function GetDiagnosticsForSpanAsync(document As TextDocument, range As TextSpan?, shouldIncludeDiagnostic As Func(Of String, Boolean), includeCompilerDiagnostics As Boolean, includeSuppressedDiagnostics As Boolean, priority As ICodeActionRequestPriorityProvider, diagnosticKinds As DiagnosticKind, isExplicit As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetDiagnosticsForSpanAsync + Public Function GetDiagnosticsForSpanAsync(document As TextDocument, range As TextSpan?, shouldIncludeDiagnostic As Func(Of String, Boolean), includeCompilerDiagnostics As Boolean, priority As ICodeActionRequestPriorityProvider, diagnosticKinds As DiagnosticKind, isExplicit As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetDiagnosticsForSpanAsync Return SpecializedTasks.EmptyImmutableArray(Of DiagnosticData) End Function - Public Function GetCachedDiagnosticsAsync(workspace As Workspace, projectId As ProjectId, documentId As DocumentId, includeSuppressedDiagnostics As Boolean, includeLocalDocumentDiagnostics As Boolean, includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetCachedDiagnosticsAsync + Public Function GetCachedDiagnosticsAsync(workspace As Workspace, projectId As ProjectId, documentId As DocumentId, includeLocalDocumentDiagnostics As Boolean, includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetCachedDiagnosticsAsync Return SpecializedTasks.EmptyImmutableArray(Of DiagnosticData)() End Function - Public Function GetDiagnosticsForIdsAsync(solution As Solution, projectId As ProjectId, documentId As DocumentId, diagnosticIds As ImmutableHashSet(Of String), shouldIncludeAnalyzer As Func(Of DiagnosticAnalyzer, Boolean), getDocuments As Func(Of Project, DocumentId, IReadOnlyList(Of DocumentId)), includeSuppressedDiagnostics As Boolean, includeLocalDocumentDiagnostics As Boolean, includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetDiagnosticsForIdsAsync + Public Function GetDiagnosticsForIdsAsync(solution As Solution, projectId As ProjectId, documentId As DocumentId, diagnosticIds As ImmutableHashSet(Of String), shouldIncludeAnalyzer As Func(Of DiagnosticAnalyzer, Boolean), getDocuments As Func(Of Project, DocumentId, IReadOnlyList(Of DocumentId)), includeLocalDocumentDiagnostics As Boolean, includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetDiagnosticsForIdsAsync Return SpecializedTasks.EmptyImmutableArray(Of DiagnosticData)() End Function - Public Function GetProjectDiagnosticsForIdsAsync(solution As Solution, projectId As ProjectId, diagnosticIds As ImmutableHashSet(Of String), shouldIncludeAnalyzer As Func(Of DiagnosticAnalyzer, Boolean), includeSuppressedDiagnostics As Boolean, includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync + Public Function GetProjectDiagnosticsForIdsAsync(solution As Solution, projectId As ProjectId, diagnosticIds As ImmutableHashSet(Of String), shouldIncludeAnalyzer As Func(Of DiagnosticAnalyzer, Boolean), includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync Return SpecializedTasks.EmptyImmutableArray(Of DiagnosticData)() End Function diff --git a/src/VisualStudio/Core/Test/Venus/DocumentService_IntegrationTests.vb b/src/VisualStudio/Core/Test/Venus/DocumentService_IntegrationTests.vb index 25ca0b50529f7..85111a14aaf6e 100644 --- a/src/VisualStudio/Core/Test/Venus/DocumentService_IntegrationTests.vb +++ b/src/VisualStudio/Core/Test/Venus/DocumentService_IntegrationTests.vb @@ -240,7 +240,7 @@ class { } ' confirm that IDE doesn't report the diagnostics Dim diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( workspace.CurrentSolution, projectId:=Nothing, documentId:=document.Id, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, - includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) + includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) Assert.False(diagnostics.Any()) End Using End Function diff --git a/src/Workspaces/Core/Portable/Diagnostics/CompilationWithAnalyzersPair.cs b/src/Workspaces/Core/Portable/Diagnostics/CompilationWithAnalyzersPair.cs index 7388477be4129..e9b7f7f73746e 100644 --- a/src/Workspaces/Core/Portable/Diagnostics/CompilationWithAnalyzersPair.cs +++ b/src/Workspaces/Core/Portable/Diagnostics/CompilationWithAnalyzersPair.cs @@ -44,8 +44,6 @@ public CompilationWithAnalyzersPair(CompilationWithAnalyzers? projectCompilation public CompilationWithAnalyzers? HostCompilationWithAnalyzers => _hostCompilationWithAnalyzers; - public bool ReportSuppressedDiagnostics => _projectCompilationWithAnalyzers?.AnalysisOptions.ReportSuppressedDiagnostics ?? _hostCompilationWithAnalyzers!.AnalysisOptions.ReportSuppressedDiagnostics; - public bool ConcurrentAnalysis => _projectCompilationWithAnalyzers?.AnalysisOptions.ConcurrentAnalysis ?? _hostCompilationWithAnalyzers!.AnalysisOptions.ConcurrentAnalysis; public bool HasAnalyzers => ProjectAnalyzers.Any() || HostAnalyzers.Any(); diff --git a/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs b/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs index 4cf2aafacf4f1..ae879b375a924 100644 --- a/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs +++ b/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs @@ -107,7 +107,6 @@ public static async Task projectAnalyzers, ImmutableArray hostAnalyzers, SkippedHostAnalyzersInfo skippedAnalyzersInfo, - bool includeSuppressedDiagnostics, CancellationToken cancellationToken) { SyntaxTree? treeToAnalyze = null; @@ -154,13 +153,13 @@ public static async Task d.Location.SourceTree == treeToAnalyze); AddDiagnosticsToResult(diagnostics, ref result, treeToAnalyze, additionalDocumentId: null, - documentAnalysisScope.Span, AnalysisKind.Semantic, diagnosticIdsToFilter, includeSuppressedDiagnostics); + documentAnalysisScope.Span, AnalysisKind.Semantic, diagnosticIdsToFilter); } } else @@ -222,7 +221,7 @@ public static async Task d.Location.SourceTree!)) { AddDiagnosticsToResult(group.AsImmutable(), ref result, group.Key, additionalDocumentId: null, - span: null, AnalysisKind.Semantic, diagnosticIdsToFilter, includeSuppressedDiagnostics); + span: null, AnalysisKind.Semantic, diagnosticIdsToFilter); } } @@ -242,13 +241,12 @@ static void AddAnalyzerDiagnosticsToResult( DocumentId? additionalDocumentId, TextSpan? span, AnalysisKind kind, - ImmutableArray diagnosticIdsToFilter, - bool includeSuppressedDiagnostics) + ImmutableArray diagnosticIdsToFilter) { if (diagnosticsByAnalyzer.TryGetValue(analyzer, out var diagnostics)) { AddDiagnosticsToResult(diagnostics, ref result, - tree, additionalDocumentId, span, kind, diagnosticIdsToFilter, includeSuppressedDiagnostics); + tree, additionalDocumentId, span, kind, diagnosticIdsToFilter); } } @@ -259,15 +257,14 @@ static void AddDiagnosticsToResult( DocumentId? additionalDocumentId, TextSpan? span, AnalysisKind kind, - ImmutableArray diagnosticIdsToFilter, - bool includeSuppressedDiagnostics) + ImmutableArray diagnosticIdsToFilter) { if (diagnostics.IsEmpty) { return; } - diagnostics = diagnostics.Filter(diagnosticIdsToFilter, includeSuppressedDiagnostics, span); + diagnostics = diagnostics.Filter(diagnosticIdsToFilter, span); switch (kind) { @@ -299,23 +296,20 @@ static void AddDiagnosticsToResult( /// /// Filters out the diagnostics with the specified . - /// If is false, filters out suppressed diagnostics. /// If is non-null, filters out diagnostics with location outside this span. /// public static ImmutableArray Filter( this ImmutableArray diagnostics, ImmutableArray diagnosticIdsToFilter, - bool includeSuppressedDiagnostics, TextSpan? filterSpan = null) { - if (diagnosticIdsToFilter.IsEmpty && includeSuppressedDiagnostics && !filterSpan.HasValue) + if (diagnosticIdsToFilter.IsEmpty && !filterSpan.HasValue) { return diagnostics; } return diagnostics.RemoveAll(diagnostic => diagnosticIdsToFilter.Contains(diagnostic.Id) || - !includeSuppressedDiagnostics && diagnostic.IsSuppressed || filterSpan.HasValue && !filterSpan.Value.IntersectsWith(diagnostic.Location.SourceSpan)); } diff --git a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/DiagnosticComputer.cs b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/DiagnosticComputer.cs index 36c3701037783..d8b597c517736 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/DiagnosticComputer.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/DiagnosticComputer.cs @@ -117,7 +117,6 @@ public static Task GetDiagnosticsAsync( DiagnosticAnalyzerInfoCache analyzerInfoCache, HostWorkspaceServices hostWorkspaceServices, bool isExplicit, - bool reportSuppressedDiagnostics, bool logPerformanceInfo, bool getTelemetryInfo, CancellationToken cancellationToken) @@ -146,14 +145,13 @@ public static Task GetDiagnosticsAsync( // from clients such as editor diagnostic tagger to show squiggles, background analysis to populate the error list, etc. var diagnosticsComputer = new DiagnosticComputer(document, project, solutionChecksum, span, analysisKind, analyzerInfoCache, hostWorkspaceServices); return isExplicit - ? diagnosticsComputer.GetHighPriorityDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, reportSuppressedDiagnostics, logPerformanceInfo, getTelemetryInfo, cancellationToken) - : diagnosticsComputer.GetNormalPriorityDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, reportSuppressedDiagnostics, logPerformanceInfo, getTelemetryInfo, cancellationToken); + ? diagnosticsComputer.GetHighPriorityDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, logPerformanceInfo, getTelemetryInfo, cancellationToken) + : diagnosticsComputer.GetNormalPriorityDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, logPerformanceInfo, getTelemetryInfo, cancellationToken); } private async Task GetHighPriorityDiagnosticsAsync( ImmutableArray projectAnalyzerIds, ImmutableArray hostAnalyzerIds, - bool reportSuppressedDiagnostics, bool logPerformanceInfo, bool getTelemetryInfo, CancellationToken cancellationToken) @@ -162,7 +160,7 @@ private async Task GetHighPriorityDiagnos // Step 1: // - Create the core 'computeTask' for computing diagnostics. - var computeTask = GetDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, reportSuppressedDiagnostics, logPerformanceInfo, getTelemetryInfo, cancellationToken); + var computeTask = GetDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, logPerformanceInfo, getTelemetryInfo, cancellationToken); // Step 2: // - Add this computeTask to the set of currently executing high priority tasks. @@ -228,7 +226,6 @@ static void CancelNormalPriorityTasks() private async Task GetNormalPriorityDiagnosticsAsync( ImmutableArray projectAnalyzerIds, ImmutableArray hostAnalyzerIds, - bool reportSuppressedDiagnostics, bool logPerformanceInfo, bool getTelemetryInfo, CancellationToken cancellationToken) @@ -257,7 +254,7 @@ private async Task GetNormalPriorityDiagn { // Step 3: // - Execute the core compute task for diagnostic computation. - return await GetDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, reportSuppressedDiagnostics, logPerformanceInfo, getTelemetryInfo, + return await GetDiagnosticsAsync(projectAnalyzerIds, hostAnalyzerIds, logPerformanceInfo, getTelemetryInfo, cancellationTokenSource.Token).ConfigureAwait(false); } catch (OperationCanceledException ex) when (ex.CancellationToken == cancellationTokenSource.Token) @@ -320,7 +317,6 @@ static async Task WaitForHighPriorityTasksAsync(CancellationToken cancellationTo private async Task GetDiagnosticsAsync( ImmutableArray projectAnalyzerIds, ImmutableArray hostAnalyzerIds, - bool reportSuppressedDiagnostics, bool logPerformanceInfo, bool getTelemetryInfo, CancellationToken cancellationToken) @@ -363,7 +359,7 @@ private async Task GetDiagnosticsAsync( var skippedAnalyzersInfo = _project.GetSkippedAnalyzersInfo(_analyzerInfoCache); return await AnalyzeAsync(compilationWithAnalyzers, analyzerToIdMap, projectAnalyzers, hostAnalyzers, skippedAnalyzersInfo, - reportSuppressedDiagnostics, logPerformanceInfo, getTelemetryInfo, cancellationToken).ConfigureAwait(false); + logPerformanceInfo, getTelemetryInfo, cancellationToken).ConfigureAwait(false); } private async Task AnalyzeAsync( @@ -372,7 +368,6 @@ private async Task AnalyzeAsync( ImmutableArray projectAnalyzers, ImmutableArray hostAnalyzers, SkippedHostAnalyzersInfo skippedAnalyzersInfo, - bool reportSuppressedDiagnostics, bool logPerformanceInfo, bool getTelemetryInfo, CancellationToken cancellationToken) @@ -407,7 +402,7 @@ private async Task AnalyzeAsync( builderMap = builderMap.AddRange(await analysisResult.ToResultBuilderMapAsync( additionalPragmaSuppressionDiagnostics, documentAnalysisScope, _project, VersionStamp.Default, - projectAnalyzers, hostAnalyzers, skippedAnalyzersInfo, reportSuppressedDiagnostics, cancellationToken).ConfigureAwait(false)); + projectAnalyzers, hostAnalyzers, skippedAnalyzersInfo, cancellationToken).ConfigureAwait(false)); } var telemetry = getTelemetryInfo diff --git a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs index b4c67951f6422..53691abc123f8 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs @@ -67,7 +67,6 @@ public async ValueTask CalculateDiagnosti arguments.ProjectAnalyzerIds, arguments.HostAnalyzerIds, documentAnalysisKind, _analyzerInfoCache, hostWorkspaceServices, isExplicit: arguments.IsExplicit, - reportSuppressedDiagnostics: arguments.ReportSuppressedDiagnostics, logPerformanceInfo: arguments.LogPerformanceInfo, getTelemetryInfo: arguments.GetTelemetryInfo, cancellationToken).ConfigureAwait(false); From 728a8cc357eddf6477c437a26289ec9154280428 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 21 Jan 2025 20:26:58 -0800 Subject: [PATCH 15/76] Remove --- .../Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs index 708f4c17c98db..000c997aa4adf 100644 --- a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs +++ b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs @@ -70,7 +70,6 @@ public async Task TestHasSuccessfullyLoadedBeingFalse() var diagnostics = await analyzer.GetDiagnosticsForIdsAsync( workspace.CurrentSolution, projectId: null, documentId: null, diagnosticIds: null, shouldIncludeAnalyzer: null, getDocuments: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, CancellationToken.None); - diagnostics = diagnostics.WhereAsArray(d => !d.IsSuppressed); Assert.NotEmpty(diagnostics); } From 5a1c0b205d9b588eee858eaf300eff816b6280df Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 21 Jan 2025 20:28:56 -0800 Subject: [PATCH 16/76] Remove --- src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb index f6f873d4aaa76..e5dfb244be47c 100644 --- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb +++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb @@ -66,8 +66,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests End Function Private Shared Async Function GetDiagnosticsForSpanAsync(diagnosticService As IDiagnosticAnalyzerService, document As Document, range As TextSpan, diagnosticKind As DiagnosticKind) As Task(Of ImmutableArray(Of DiagnosticData)) - Dim diagnostics = Await diagnosticService.GetDiagnosticsForSpanAsync(document, range, diagnosticKind, CancellationToken.None) - Return diagnostics.WhereAsArray(Function(d) Not d.IsSuppressed) + Return Await diagnosticService.GetDiagnosticsForSpanAsync(document, range, diagnosticKind, CancellationToken.None) End Function From e5b1721fd12d99fd6fad16bc0a96049488d8148e Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 21 Jan 2025 20:34:51 -0800 Subject: [PATCH 17/76] Fix --- ...CodeFixService.FixAllDiagnosticProvider.cs | 32 ++++++++++++++----- 1 file changed, 24 insertions(+), 8 deletions(-) diff --git a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs index 98da7ff2b74e6..55bde7157b61e 100644 --- a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs +++ b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.FixAllDiagnosticProvider.cs @@ -20,6 +20,7 @@ private sealed class FixAllDiagnosticProvider : FixAllContext.SpanBasedDiagnosti { private readonly IDiagnosticAnalyzerService _diagnosticService; private readonly ImmutableHashSet? _diagnosticIds; + private readonly bool _includeSuppressedDiagnostics; public FixAllDiagnosticProvider(IDiagnosticAnalyzerService diagnosticService, ImmutableHashSet diagnosticIds) { @@ -28,14 +29,26 @@ public FixAllDiagnosticProvider(IDiagnosticAnalyzerService diagnosticService, Im // When computing FixAll for unnecessary pragma suppression diagnostic, // we need to include suppressed diagnostics, as well as reported compiler and analyzer diagnostics. // A null value for '_diagnosticIds' ensures the latter. - _diagnosticIds = diagnosticIds.Contains(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId) - ? null : diagnosticIds; + if (diagnosticIds.Contains(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId)) + { + _diagnosticIds = null; + _includeSuppressedDiagnostics = true; + } + else + { + _diagnosticIds = diagnosticIds; + _includeSuppressedDiagnostics = false; + } } + private ImmutableArray Filter(ImmutableArray diagnostics) + => diagnostics.WhereAsArray(d => _includeSuppressedDiagnostics || !d.IsSuppressed); + public override async Task> GetDocumentDiagnosticsAsync(Document document, CancellationToken cancellationToken) { var solution = document.Project.Solution; - var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(solution, projectId: null, document.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = Filter(await _diagnosticService.GetDiagnosticsForIdsAsync( + solution, projectId: null, document.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false)); Contract.ThrowIfFalse(diagnostics.All(d => d.DocumentId != null)); return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false); } @@ -43,9 +56,10 @@ public override async Task> GetDocumentDiagnosticsAsync( public override async Task> GetDocumentSpanDiagnosticsAsync(Document document, TextSpan fixAllSpan, CancellationToken cancellationToken) { bool shouldIncludeDiagnostic(string id) => _diagnosticIds == null || _diagnosticIds.Contains(id); - var diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync(document, fixAllSpan, shouldIncludeDiagnostic, - includeCompilerDiagnostics: true, priorityProvider: new DefaultCodeActionRequestPriorityProvider(), - DiagnosticKind.All, isExplicit: false, cancellationToken).ConfigureAwait(false); + var diagnostics = Filter(await _diagnosticService.GetDiagnosticsForSpanAsync( + document, fixAllSpan, shouldIncludeDiagnostic, includeCompilerDiagnostics: true, + priorityProvider: new DefaultCodeActionRequestPriorityProvider(), + DiagnosticKind.All, isExplicit: false, cancellationToken).ConfigureAwait(false)); Contract.ThrowIfFalse(diagnostics.All(d => d.DocumentId != null)); return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false); } @@ -53,14 +67,16 @@ public override async Task> GetDocumentSpanDiagnosticsAs public override async Task> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) { // Get all diagnostics for the entire project, including document diagnostics. - var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId: null, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = Filter(await _diagnosticService.GetDiagnosticsForIdsAsync( + project.Solution, project.Id, documentId: null, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false)); return await diagnostics.ToDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false); } public override async Task> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) { // Get all no-location diagnostics for the project, doesn't include document diagnostics. - var diagnostics = await _diagnosticService.GetProjectDiagnosticsForIdsAsync(project.Solution, project.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); + var diagnostics = Filter(await _diagnosticService.GetProjectDiagnosticsForIdsAsync( + project.Solution, project.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false)); Contract.ThrowIfFalse(diagnostics.All(d => d.DocumentId == null)); return await diagnostics.ToDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false); } From 25e37fb878b476df4d5a3f70506aa6ea77eed045 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 21 Jan 2025 20:36:01 -0800 Subject: [PATCH 18/76] Fix --- src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs index 90c924e03d4bd..92a5b0b205e2c 100644 --- a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs +++ b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs @@ -200,6 +200,7 @@ public async IAsyncEnumerable StreamFixesAsync( diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync( document, range, GetShouldIncludeDiagnosticPredicate(document, priorityProvider), includeCompilerDiagnostics: true, priorityProvider, DiagnosticKind.All, isExplicit: true, cancellationToken).ConfigureAwait(false); + diagnostics = diagnostics.WhereAsArray(d => includeSuppressionFixes || !d.IsSuppressed); } var copilotDiagnostics = await GetCopilotDiagnosticsAsync(document, range, priorityProvider.Priority, cancellationToken).ConfigureAwait(false); From 4202e2d5592fb12cc736db0020f553023759c99f Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 09:11:43 -0800 Subject: [PATCH 19/76] Initial work to collapse comments at the end of a block --- .../CSharpTest/Structure/BlockSyntaxStructureTests.cs | 9 +++++---- .../CSharp/Portable/Structure/CSharpStructureHelpers.cs | 6 +++--- .../Structure/Providers/BlockSyntaxStructureProvider.cs | 3 +++ .../Providers/TypeDeclarationStructureProvider.cs | 2 +- 4 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs b/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs index a6d5fc0d3b6c2..03647b3a546df 100644 --- a/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs +++ b/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs @@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Structure; [Trait(Traits.Feature, Traits.Features.Outlining)] -public class BlockSyntaxStructureTests : AbstractCSharpSyntaxNodeStructureTests +public sealed class BlockSyntaxStructureTests : AbstractCSharpSyntaxNodeStructureTests { internal override AbstractSyntaxStructureProvider CreateProvider() => new BlockSyntaxStructureProvider(); @@ -480,16 +480,17 @@ class C { void M() { - {|hint:static void Goo(){|textspan: + {|hint1:static void Goo(){|textspan1: {$$ - // ... + {|hint2:{|textspan2:// ...|}|} }|}|} } } """; await VerifyBlockSpansAsync(code, - Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: false)); + Region("textspan1", "hint1", CSharpStructureHelpers.Ellipsis, autoCollapse: false), + Region("textspan2", "hint2", "// ... ...", autoCollapse: false)); } [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/68513")] diff --git a/src/Features/CSharp/Portable/Structure/CSharpStructureHelpers.cs b/src/Features/CSharp/Portable/Structure/CSharpStructureHelpers.cs index e7b9ea1f7f0b0..f32d1420cf2c7 100644 --- a/src/Features/CSharp/Portable/Structure/CSharpStructureHelpers.cs +++ b/src/Features/CSharp/Portable/Structure/CSharpStructureHelpers.cs @@ -187,14 +187,14 @@ public static void CollectCommentBlockSpans( else if (trivia is not SyntaxTrivia( SyntaxKind.WhitespaceTrivia or SyntaxKind.EndOfLineTrivia or SyntaxKind.EndOfFileToken)) { - completeSingleLineCommentGroup(spans); + CompleteSingleLineCommentGroup(spans); } } - completeSingleLineCommentGroup(spans); + CompleteSingleLineCommentGroup(spans); return; - void completeSingleLineCommentGroup(ArrayBuilder spans) + void CompleteSingleLineCommentGroup(ArrayBuilder spans) { if (startComment != null) { diff --git a/src/Features/CSharp/Portable/Structure/Providers/BlockSyntaxStructureProvider.cs b/src/Features/CSharp/Portable/Structure/Providers/BlockSyntaxStructureProvider.cs index 7b8d2062f5c84..5c96efa3c8be2 100644 --- a/src/Features/CSharp/Portable/Structure/Providers/BlockSyntaxStructureProvider.cs +++ b/src/Features/CSharp/Portable/Structure/Providers/BlockSyntaxStructureProvider.cs @@ -142,6 +142,9 @@ protected override void CollectBlockSpans( type: type)); } } + + // Add any leading comments before the end of the block + CSharpStructureHelpers.CollectCommentBlockSpans(node.CloseBraceToken.LeadingTrivia, spans); } private static bool IsNonBlockStatement(SyntaxNode node) diff --git a/src/Features/CSharp/Portable/Structure/Providers/TypeDeclarationStructureProvider.cs b/src/Features/CSharp/Portable/Structure/Providers/TypeDeclarationStructureProvider.cs index 11ed11b058e17..f58c8340f1818 100644 --- a/src/Features/CSharp/Portable/Structure/Providers/TypeDeclarationStructureProvider.cs +++ b/src/Features/CSharp/Portable/Structure/Providers/TypeDeclarationStructureProvider.cs @@ -11,7 +11,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Structure; -internal class TypeDeclarationStructureProvider : AbstractSyntaxNodeStructureProvider +internal sealed class TypeDeclarationStructureProvider : AbstractSyntaxNodeStructureProvider { protected override void CollectBlockSpans( SyntaxToken previousToken, From af41d67c059056fa445e25c17f6a4bb3f133dcae Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 09:19:30 -0800 Subject: [PATCH 20/76] Use Assert.Empty --- .../Test/Collections/Immutable/Maps/MapTests.cs | 4 ++-- .../Test/Extensions/CollectionExtensionsTest.cs | 6 +++--- .../AbstractMetadataAsSourceTests.TestContext.cs | 4 ++-- .../Test2/CodeFixes/CodeFixServiceTests.vb | 8 ++++---- .../Test2/Diagnostics/DiagnosticProviderTests.vb | 2 +- .../Test2/Diagnostics/DiagnosticServiceTests.vb | 14 +++++++------- .../TestUtilities/Rename/RenamerTests.cs | 2 +- .../Recommendations/RecommendationTestHelpers.vb | 2 +- .../Test/ExpressionCompiler/LocalFunctionTests.cs | 4 ++-- .../CSharp/Test/ExpressionCompiler/LocalsTests.cs | 12 ++++++------ .../Test/ExpressionCompiler/UsingDebugInfoTests.cs | 4 ++-- .../Test/ExpressionCompiler/LocalsTests.vb | 10 +++++----- .../Diagnostics/PullDiagnosticTests.cs | 6 +++--- .../RelatedDocuments/RelatedDocumentsTests.cs | 2 +- .../CoreTest.Desktop/GlobalAssemblyCacheTests.cs | 8 ++++---- .../Test/DocumentOutline/DocumentOutlineTests.cs | 2 +- .../CodeGeneration/SyntaxGeneratorTests.cs | 6 +++--- .../CodeGeneration/SyntaxGeneratorTests.vb | 6 +++--- 18 files changed, 51 insertions(+), 51 deletions(-) diff --git a/src/EditorFeatures/Test/Collections/Immutable/Maps/MapTests.cs b/src/EditorFeatures/Test/Collections/Immutable/Maps/MapTests.cs index 94f2d5822f574..11a1d52fdbfd1 100644 --- a/src/EditorFeatures/Test/Collections/Immutable/Maps/MapTests.cs +++ b/src/EditorFeatures/Test/Collections/Immutable/Maps/MapTests.cs @@ -76,7 +76,7 @@ public void TestRemove() Assert.Equal(1, map.Count); map = map.Remove("5"); - Assert.Equal(0, map.Count); + Assert.Empty(map); } [Fact] @@ -116,7 +116,7 @@ public void TestPathology() Assert.Equal(1, map.Count); map = map.Remove("5"); - Assert.Equal(0, map.Count); + Assert.Empty(map); } private class PathologicalComparer : IEqualityComparer diff --git a/src/EditorFeatures/Test/Extensions/CollectionExtensionsTest.cs b/src/EditorFeatures/Test/Extensions/CollectionExtensionsTest.cs index cc184d27aaac6..6a4dfe5942975 100644 --- a/src/EditorFeatures/Test/Extensions/CollectionExtensionsTest.cs +++ b/src/EditorFeatures/Test/Extensions/CollectionExtensionsTest.cs @@ -21,7 +21,7 @@ public void PushReverse1() Assert.Equal(1, stack.Pop()); Assert.Equal(2, stack.Pop()); Assert.Equal(3, stack.Pop()); - Assert.Equal(0, stack.Count); + Assert.Empty(stack); } [Fact] @@ -29,7 +29,7 @@ public void PushReverse2() { var stack = new Stack(); stack.PushReverse(Array.Empty()); - Assert.Equal(0, stack.Count); + Assert.Empty(stack); } [Fact] @@ -41,6 +41,6 @@ public void PushReverse3() Assert.Equal(1, stack.Pop()); Assert.Equal(2, stack.Pop()); Assert.Equal(3, stack.Pop()); - Assert.Equal(0, stack.Count); + Assert.Empty(stack); } } diff --git a/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs b/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs index d0686f539086b..8e00e418bd095 100644 --- a/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs +++ b/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs @@ -104,7 +104,7 @@ public async Task GenerateSourceAsync( // Get an ISymbol corresponding to the metadata name var compilation = await project.GetRequiredCompilationAsync(CancellationToken.None); var diagnostics = compilation.GetDiagnostics().ToArray(); - Assert.Equal(0, diagnostics.Length); + Assert.Empty(diagnostics); var symbol = await ResolveSymbolAsync(symbolMetadataName, compilation); Contract.ThrowIfNull(symbol); @@ -172,7 +172,7 @@ public void Dispose() { compilation = await this.DefaultProject.GetRequiredCompilationAsync(CancellationToken.None); var diagnostics = compilation.GetDiagnostics().ToArray(); - Assert.Equal(0, diagnostics.Length); + Assert.Empty(diagnostics); } foreach (var reference in compilation.References) diff --git a/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb b/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb index 5b996eecaa62c..daa4127eee1c4 100644 --- a/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb +++ b/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb @@ -78,7 +78,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests (Await document.GetSyntaxRootAsync()).FullSpan, CancellationToken.None) - Assert.Equal(0, fixes.Length) + Assert.Empty(fixes) ' Verify available codefix with a global fixer + a project fixer ' We will use this assembly as a project fixer provider. @@ -102,7 +102,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests (Await document.GetSyntaxRootAsync()).FullSpan, CancellationToken.None) - Assert.Equal(0, fixes.Length) + Assert.Empty(fixes) End Using End Function @@ -150,7 +150,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests (Await document.GetSyntaxRootAsync()).FullSpan, CancellationToken.None) - Assert.Equal(0, fixes.Length) + Assert.Empty(fixes) ' Verify no codefix with a global fixer + a project fixer ' We will use this assembly as a project fixer provider. @@ -165,7 +165,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests (Await document.GetSyntaxRootAsync()).FullSpan, CancellationToken.None) - Assert.Equal(0, fixes.Length) + Assert.Empty(fixes) End Using End Function diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb index 088b930be272f..529c101cda77e 100644 --- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb +++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb @@ -266,7 +266,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None).Result If diagnostics Is Nothing Then - Assert.Equal(0, actualDiagnostics.Length) + Assert.Empty(actualDiagnostics) Else Dim expectedDiagnostics = GetExpectedDiagnostics(workspace, diagnostics) diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb index 3a9f4c2a0ec60..fe9d71920dda3 100644 --- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb +++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb @@ -300,7 +300,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests project = project.WithCompilationOptions(newCompilationOptions) document = project.Documents.Single() diagnostics = Await GetDiagnosticsForSpanAsync(diagnosticService, document, span) - Assert.Equal(0, diagnostics.Length) + Assert.Empty(diagnostics) Dim changeSeverityDiagOptions = New Dictionary(Of String, ReportDiagnostic) changeSeverityDiagOptions.Add(workspaceDiagnosticAnalyzer.DiagDescriptor.Id, ReportDiagnostic.Error) @@ -350,7 +350,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests Dim hostAnalyzers = solution.SolutionState.Analyzers Dim workspaceDescriptors = hostAnalyzers.GetDiagnosticDescriptorsPerReference(diagnosticService.AnalyzerInfoCache) - Assert.Equal(0, workspaceDescriptors.Count) + Assert.Empty(workspaceDescriptors) Dim descriptors1 = hostAnalyzers.GetDiagnosticDescriptorsPerReference(diagnosticService.AnalyzerInfoCache, p1) Assert.Equal("XX0001", descriptors1.Single().Value.Single().Id) @@ -494,14 +494,14 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests Dim descriptorsMap = solution.SolutionState.Analyzers.GetDiagnosticDescriptorsPerReference(diagnosticService.AnalyzerInfoCache, project) Assert.Equal(1, descriptorsMap.Count) Dim descriptors = descriptorsMap.First().Value - Assert.Equal(0, descriptors.Length) + Assert.Empty(descriptors) Dim document = project.Documents.Single() Dim incrementalAnalyzer = diagnosticService.CreateIncrementalAnalyzer(workspace) Dim diagnostics = Await GetDiagnosticsForDocumentAsync(diagnosticService, document) - Assert.Equal(0, diagnostics.Length) + Assert.Empty(diagnostics) End Using End Function @@ -534,7 +534,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests Dim incrementalAnalyzer = diagnosticService.CreateIncrementalAnalyzer(workspace) Dim root = Await document.GetSyntaxRootAsync().ConfigureAwait(False) Dim diagnostics = Await GetDiagnosticsForSpanAsync(diagnosticService, document, root.FullSpan) - Assert.Equal(0, diagnostics.Length) + Assert.Empty(diagnostics) diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, projectId:=Nothing, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, @@ -2096,7 +2096,7 @@ class MyClass Dim document = project.Documents.Single() Dim diagnostics = Await GetDiagnosticsForDocumentAsync(diagnosticService, document) - Assert.Equal(0, diagnostics.Length) + Assert.Empty(diagnostics) End Using End Function @@ -2237,7 +2237,7 @@ class C Dim diagnostics = Await diagnosticService.GetDiagnosticsForIdsAsync( project.Solution, project.Id, documentId:=Nothing, diagnosticIds:=Nothing, shouldIncludeAnalyzer:=Nothing, includeSuppressedDiagnostics:=False, includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) - Assert.Equal(0, diagnostics.Length) + Assert.Empty(diagnostics) End Using End Function diff --git a/src/EditorFeatures/TestUtilities/Rename/RenamerTests.cs b/src/EditorFeatures/TestUtilities/Rename/RenamerTests.cs index 3b70d661c01e3..d628c3bfc5e96 100644 --- a/src/EditorFeatures/TestUtilities/Rename/RenamerTests.cs +++ b/src/EditorFeatures/TestUtilities/Rename/RenamerTests.cs @@ -99,7 +99,7 @@ protected async Task TestRenameDocument( } AssertEx.EqualOrDiff(endDocument.Text, (await updatedDocument.GetTextAsync()).ToString()); - Assert.Equal(0, remainingErrors.Count); + Assert.Empty(remainingErrors); } } diff --git a/src/EditorFeatures/VisualBasicTest/Recommendations/RecommendationTestHelpers.vb b/src/EditorFeatures/VisualBasicTest/Recommendations/RecommendationTestHelpers.vb index 15f02976ee58c..d9e46a4ee0d3a 100644 --- a/src/EditorFeatures/VisualBasicTest/Recommendations/RecommendationTestHelpers.vb +++ b/src/EditorFeatures/VisualBasicTest/Recommendations/RecommendationTestHelpers.vb @@ -147,7 +147,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Recommendations .OrderBy(Function(recommendation) recommendation) _ .ToArray() - Assert.Equal(0, recommendedKeywords.Length) + Assert.Empty(recommendedKeywords) End Sub Private Function GetSourceCodeKind(testSource As XElement) As SourceCodeKind diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalFunctionTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalFunctionTests.cs index e81aed85b3051..6e768a7bc4c8e 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalFunctionTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalFunctionTests.cs @@ -41,8 +41,8 @@ int G() string typeName; var assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData); Assert.NotNull(assembly); - Assert.Equal(0, assembly.Count); - Assert.Equal(0, locals.Count); + Assert.Empty(assembly); + Assert.Empty(locals); locals.Free(); }); } diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs index 288b380a00f08..27c357e83e38b 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs @@ -46,8 +46,8 @@ static void M() string typeName; var assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData); Assert.NotNull(assembly); - Assert.Equal(0, assembly.Count); - Assert.Equal(0, locals.Count); + Assert.Empty(assembly); + Assert.Empty(locals); locals.Free(); }); } @@ -2491,7 +2491,7 @@ static void M(A a, B b, C c) Diagnostic(ErrorCode.ERR_NoTypeDef).WithArguments("A", "Comp1, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(1, 1) ]); - Assert.Equal(0, locals.Count); + Assert.Empty(locals); locals.Free(); }); } @@ -2535,7 +2535,7 @@ static void M(object o) where T : I Diagnostic(ErrorCode.ERR_NoTypeDef).WithArguments("I", "Comp1, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(1, 1) ]); - Assert.Equal(0, locals.Count); + Assert.Empty(locals); locals.Free(); }); } @@ -5116,7 +5116,7 @@ private static void GetLocals(RuntimeInstance runtime, string methodName, bool a Assert.NotNull(assembly); if (count == 0) { - Assert.Equal(0, assembly.Count); + Assert.Empty(assembly); } else { @@ -5156,7 +5156,7 @@ private static void GetLocals(RuntimeInstance runtime, string methodName, Method Assert.NotNull(assembly); if (count == 0) { - Assert.Equal(0, assembly.Count); + Assert.Empty(assembly); } else { diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/UsingDebugInfoTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/UsingDebugInfoTests.cs index 27a7d762f5b1c..1bdf2288df498 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/UsingDebugInfoTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/UsingDebugInfoTests.cs @@ -405,11 +405,11 @@ public void BadPdb_ForwardChain() importStrings = CustomDebugInfoReader.GetCSharpGroupedImportStrings(methodToken2, 0, getMethodCustomDebugInfo, getMethodImportStrings, out externAliasStrings); Assert.Equal(importString, importStrings.Single().Single()); - Assert.Equal(0, externAliasStrings.Length); + Assert.Empty(externAliasStrings); importStrings = CustomDebugInfoReader.GetCSharpGroupedImportStrings(methodToken2, 0, getMethodCustomDebugInfo, getMethodImportStrings, out externAliasStrings); Assert.Equal(importString, importStrings.Single().Single()); - Assert.Equal(0, externAliasStrings.Length); + Assert.Empty(externAliasStrings); } [Fact] diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb index 06b0ccd3d7737..b3bbf6b46a89f 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb @@ -36,8 +36,8 @@ End Class" Dim typeName As String = Nothing Dim assembly = context.CompileGetLocals(locals, argumentsOnly:=False, typeName:=typeName, testData:=testData) Assert.NotNull(assembly) - Assert.Equal(0, assembly.Count) - Assert.Equal(0, locals.Count) + Assert.Empty(assembly) + Assert.Empty(locals) locals.Free() End Sub) End Sub @@ -1789,7 +1789,7 @@ End Class" Diagnostic(ERRID.ERR_TypeRefResolutionError3, "a").WithArguments("A", "Test.dll").WithLocation(1, 1) }) - Assert.Equal(0, locals.Count) + Assert.Empty(locals) locals.Free() End Sub) End Sub @@ -3373,7 +3373,7 @@ End Class" Assert.NotNull(assembly) If count = 0 Then - Assert.Equal(0, assembly.Count) + Assert.Empty(assembly) Else Assert.InRange(assembly.Count, 0, Integer.MaxValue) End If @@ -3408,7 +3408,7 @@ End Class" Assert.NotNull(assembly) If count = 0 Then - Assert.Equal(0, assembly.Count) + Assert.Empty(assembly) Else Assert.InRange(assembly.Count, 0, Integer.MaxValue) End If diff --git a/src/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs b/src/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs index 8e5958674d2b3..a840823f2adc5 100644 --- a/src/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs +++ b/src/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs @@ -1049,7 +1049,7 @@ class A { var results = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics: true, includeTaskListItems: false, category: PullDiagnosticCategories.Task); - Assert.Equal(0, results.Length); + Assert.Empty(results); } [Theory, CombinatorialData] @@ -1115,7 +1115,7 @@ class A { var results = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics: true, includeTaskListItems: false, category: PullDiagnosticCategories.Task); - Assert.Equal(0, results.Length); + Assert.Empty(results); } [Theory, CombinatorialData] @@ -2115,7 +2115,7 @@ public async Task TestWorkspaceDiagnosticsForClosedFilesSwitchFSAFromOffToOn(boo var results = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics); - Assert.Equal(0, results.Length); + Assert.Empty(results); var options = testLspServer.TestWorkspace.ExportProvider.GetExportedValue(); options.SetGlobalOption(SolutionCrawlerOptionsStorage.BackgroundAnalysisScopeOption, LanguageNames.CSharp, BackgroundAnalysisScope.FullSolution); diff --git a/src/LanguageServer/ProtocolUnitTests/RelatedDocuments/RelatedDocumentsTests.cs b/src/LanguageServer/ProtocolUnitTests/RelatedDocuments/RelatedDocumentsTests.cs index 6679d9089c729..979a37c00517c 100644 --- a/src/LanguageServer/ProtocolUnitTests/RelatedDocuments/RelatedDocumentsTests.cs +++ b/src/LanguageServer/ProtocolUnitTests/RelatedDocuments/RelatedDocumentsTests.cs @@ -67,7 +67,7 @@ class Y project.Documents.First().GetURI(), useProgress: useProgress); - Assert.Equal(0, results.Length); + Assert.Empty(results); } [Theory, CombinatorialData] diff --git a/src/Scripting/CoreTest.Desktop/GlobalAssemblyCacheTests.cs b/src/Scripting/CoreTest.Desktop/GlobalAssemblyCacheTests.cs index ae6fe5dc8413d..570e5f1f5d8a2 100644 --- a/src/Scripting/CoreTest.Desktop/GlobalAssemblyCacheTests.cs +++ b/src/Scripting/CoreTest.Desktop/GlobalAssemblyCacheTests.cs @@ -72,17 +72,17 @@ public void GetAssemblyIdentities() } names = gac.GetAssemblyIdentities("x\u0002").ToArray(); - Assert.Equal(0, names.Length); + Assert.Empty(names); names = gac.GetAssemblyIdentities("\0").ToArray(); - Assert.Equal(0, names.Length); + Assert.Empty(names); names = gac.GetAssemblyIdentities("xxxx\0xxxxx").ToArray(); - Assert.Equal(0, names.Length); + Assert.Empty(names); // fusion API CreateAssemblyEnum returns S_FALSE for this name names = gac.GetAssemblyIdentities("nonexistingassemblyname" + Guid.NewGuid().ToString()).ToArray(); - Assert.Equal(0, names.Length); + Assert.Empty(names); } [Fact] diff --git a/src/VisualStudio/CSharp/Test/DocumentOutline/DocumentOutlineTests.cs b/src/VisualStudio/CSharp/Test/DocumentOutline/DocumentOutlineTests.cs index 7612de9217e32..cd5a14b769f45 100644 --- a/src/VisualStudio/CSharp/Test/DocumentOutline/DocumentOutlineTests.cs +++ b/src/VisualStudio/CSharp/Test/DocumentOutline/DocumentOutlineTests.cs @@ -146,7 +146,7 @@ public async Task TestSearchDocumentSymbolData() // No search results found searchedSymbols = DocumentOutlineViewModel.SearchDocumentSymbolData(model.DocumentSymbolData, "xyz", CancellationToken.None); - Assert.Equal(0, searchedSymbols.Length); + Assert.Empty(searchedSymbols); } [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/66012")] diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index 0c2cbcda08cff..717c86bb6493b 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -1966,7 +1966,7 @@ public void TestAddAttributesToAccessors() private void CheckAddRemoveAttribute(SyntaxNode declaration) { var initialAttributes = Generator.GetAttributes(declaration); - Assert.Equal(0, initialAttributes.Count); + Assert.Empty(initialAttributes); var withAttribute = Generator.AddAttributes(declaration, Generator.Attribute("a")); var attrsAdded = Generator.GetAttributes(withAttribute); @@ -1974,7 +1974,7 @@ private void CheckAddRemoveAttribute(SyntaxNode declaration) var withoutAttribute = Generator.RemoveNode(withAttribute, attrsAdded[0]); var attrsRemoved = Generator.GetAttributes(withoutAttribute); - Assert.Equal(0, attrsRemoved.Count); + Assert.Empty(attrsRemoved); } [Fact] @@ -3662,7 +3662,7 @@ public void TestGetBaseAndInterfaceTypes() var baseListN = Generator.GetBaseAndInterfaceTypes(classN); Assert.NotNull(baseListN); - Assert.Equal(0, baseListN.Count); + Assert.Empty(baseListN); } [Fact] diff --git a/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb b/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb index 540d27ed70c97..396e593be6062 100644 --- a/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb +++ b/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb @@ -2285,7 +2285,7 @@ End Class Private Sub CheckAddRemoveAttribute(declaration As SyntaxNode) Dim initialAttributes = Generator.GetAttributes(declaration) - Assert.Equal(0, initialAttributes.Count) + Assert.Empty(initialAttributes) Dim withAttribute = Generator.AddAttributes(declaration, Generator.Attribute("a")) Dim attrsAdded = Generator.GetAttributes(withAttribute) @@ -2293,7 +2293,7 @@ End Class Dim withoutAttribute = Generator.RemoveNode(withAttribute, attrsAdded(0)) Dim attrsRemoved = Generator.GetAttributes(withoutAttribute) - Assert.Equal(0, attrsRemoved.Count) + Assert.Empty(attrsRemoved) End Sub @@ -3226,7 +3226,7 @@ End Class").Members(0) Dim baseListN = Generator.GetBaseAndInterfaceTypes(classN) Assert.NotNull(baseListN) - Assert.Equal(0, baseListN.Count) + Assert.Empty(baseListN) End Sub From 4ad7f3722522279c5ea93fcaa83104f330fd6522 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 11:17:06 -0800 Subject: [PATCH 21/76] Update tests --- .../Structure/BlockSyntaxStructureTests.cs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs b/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs index 03647b3a546df..b4537ed5e73af 100644 --- a/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs +++ b/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs @@ -464,12 +464,13 @@ public async Task LocalFunctionInTopLevelStatement_AutoCollapse() {|hint:static void Goo(){|textspan: {$$ - // ... + {|hint2:{|textspan2:// ...|}|} }|}|} """; await VerifyBlockSpansAsync(code, - Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: true)); + Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: true), + Region("textspan2", "hint2", "// ... ...", autoCollapse: true)); } [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/68513")] @@ -490,7 +491,7 @@ void M() await VerifyBlockSpansAsync(code, Region("textspan1", "hint1", CSharpStructureHelpers.Ellipsis, autoCollapse: false), - Region("textspan2", "hint2", "// ... ...", autoCollapse: false)); + Region("textspan2", "hint2", "// ... ...", autoCollapse: true)); } [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/68513")] @@ -503,7 +504,7 @@ void M() { {|hint:static void Goo(){|textspan: {$$ - // ... + {|hint2:{|textspan2:// ...|}|} }|}|} } } @@ -512,6 +513,7 @@ void M() await VerifyBlockSpansAsync(code, GetDefaultOptions() with { CollapseLocalFunctionsWhenCollapsingToDefinitions = true, - }, Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: true)); + }, Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: true), + Region("textspan2", "hint2", "// ... ...", autoCollapse: true)); } } From ab3a37bbce476e1962b9607c1c37cd0ddfff57d3 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 11:17:08 -0800 Subject: [PATCH 22/76] Update tests --- .../Structure/BlockSyntaxStructureTests.cs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs b/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs index b4537ed5e73af..1d4feb02e239b 100644 --- a/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs +++ b/src/EditorFeatures/CSharpTest/Structure/BlockSyntaxStructureTests.cs @@ -464,13 +464,13 @@ public async Task LocalFunctionInTopLevelStatement_AutoCollapse() {|hint:static void Goo(){|textspan: {$$ - {|hint2:{|textspan2:// ...|}|} + {|hint2:{|textspan2:// comment|}|} }|}|} """; await VerifyBlockSpansAsync(code, Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: true), - Region("textspan2", "hint2", "// ... ...", autoCollapse: true)); + Region("textspan2", "hint2", "// comment ...", autoCollapse: true)); } [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/68513")] @@ -483,7 +483,7 @@ void M() { {|hint1:static void Goo(){|textspan1: {$$ - {|hint2:{|textspan2:// ...|}|} + {|hint2:{|textspan2:// comment|}|} }|}|} } } @@ -491,7 +491,7 @@ void M() await VerifyBlockSpansAsync(code, Region("textspan1", "hint1", CSharpStructureHelpers.Ellipsis, autoCollapse: false), - Region("textspan2", "hint2", "// ... ...", autoCollapse: true)); + Region("textspan2", "hint2", "// comment ...", autoCollapse: true)); } [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/68513")] @@ -504,7 +504,7 @@ void M() { {|hint:static void Goo(){|textspan: {$$ - {|hint2:{|textspan2:// ...|}|} + {|hint2:{|textspan2:// comment|}|} }|}|} } } @@ -514,6 +514,6 @@ await VerifyBlockSpansAsync(code, GetDefaultOptions() with { CollapseLocalFunctionsWhenCollapsingToDefinitions = true, }, Region("textspan", "hint", CSharpStructureHelpers.Ellipsis, autoCollapse: true), - Region("textspan2", "hint2", "// ... ...", autoCollapse: true)); + Region("textspan2", "hint2", "// comment ...", autoCollapse: true)); } } From 5984584d1545f08b64d14ba851992badfd542afa Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 11:24:50 -0800 Subject: [PATCH 23/76] Remove unused usings --- .../Test2/Diagnostics/DiagnosticServiceTests.vb | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb index dc27badb594b0..d6a56bdf6597c 100644 --- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb +++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb @@ -7,18 +7,12 @@ Imports System.IO Imports System.Reflection Imports System.Threading Imports Microsoft.CodeAnalysis -Imports Microsoft.CodeAnalysis.CodeActions Imports Microsoft.CodeAnalysis.CommonDiagnosticAnalyzers Imports Microsoft.CodeAnalysis.CSharp -Imports Microsoft.CodeAnalysis.CSharp.Syntax Imports Microsoft.CodeAnalysis.Diagnostics Imports Microsoft.CodeAnalysis.Diagnostics.CSharp Imports Microsoft.CodeAnalysis.Editor.UnitTests -Imports Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics -Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces Imports Microsoft.CodeAnalysis.Host.Mef -Imports Microsoft.CodeAnalysis.Options -Imports Microsoft.CodeAnalysis.Simplification Imports Microsoft.CodeAnalysis.SolutionCrawler Imports Microsoft.CodeAnalysis.Text Imports Microsoft.CodeAnalysis.UnitTests.Diagnostics From 30a06703b60e6fe652787b5d18787131fd5aa515 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 11:29:20 -0800 Subject: [PATCH 24/76] Simplify --- .../Protocol/Features/CodeFixes/CodeFixService.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs index 92a5b0b205e2c..c78d9bd421e96 100644 --- a/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs +++ b/src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs @@ -200,7 +200,8 @@ public async IAsyncEnumerable StreamFixesAsync( diagnostics = await _diagnosticService.GetDiagnosticsForSpanAsync( document, range, GetShouldIncludeDiagnosticPredicate(document, priorityProvider), includeCompilerDiagnostics: true, priorityProvider, DiagnosticKind.All, isExplicit: true, cancellationToken).ConfigureAwait(false); - diagnostics = diagnostics.WhereAsArray(d => includeSuppressionFixes || !d.IsSuppressed); + if (!includeSuppressionFixes) + diagnostics = diagnostics.WhereAsArray(d => !d.IsSuppressed); } var copilotDiagnostics = await GetCopilotDiagnosticsAsync(document, range, priorityProvider.Priority, cancellationToken).ConfigureAwait(false); From e9fa4a6e5f9a4d241adda042b99b4f0e0e1cc61c Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 11:31:17 -0800 Subject: [PATCH 25/76] Update doc --- .../AbstractWorkspaceDocumentDiagnosticSource.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs index 3068142d6f844..9becd49893ea4 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs @@ -82,7 +82,8 @@ AsyncLazy> GetLazyDiagnostics() static (project, _) => [.. project.DocumentIds.Concat(project.AdditionalDocumentIds)], includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false); - // TODO(cyrusn): Should we be filtering out suppressed diagnostics here? + // TODO(cyrusn): Should we be filtering out suppressed diagnostics here? This is how the + // code has always worked, but it isn't clear if that is correct. return allDiagnostics.Where(d => !d.IsSuppressed && d.DocumentId != null).ToLookup(d => d.DocumentId!); })); } From 34820936cbe58adf7a65655bb08062e7dec52a81 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Wed, 22 Jan 2025 11:43:55 -0800 Subject: [PATCH 26/76] move into loop --- src/Tools/ExternalAccess/Razor/Cohost/Handlers/Diagnostics.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Tools/ExternalAccess/Razor/Cohost/Handlers/Diagnostics.cs b/src/Tools/ExternalAccess/Razor/Cohost/Handlers/Diagnostics.cs index caf4fe989829f..f22cafb4e8384 100644 --- a/src/Tools/ExternalAccess/Razor/Cohost/Handlers/Diagnostics.cs +++ b/src/Tools/ExternalAccess/Razor/Cohost/Handlers/Diagnostics.cs @@ -22,7 +22,6 @@ internal static class Diagnostics var diagnostics = await diagnosticAnalyzerService.GetDiagnosticsForSpanAsync( document, range: null, DiagnosticKind.All, cancellationToken).ConfigureAwait(false); - diagnostics = diagnostics.WhereAsArray(d => !d.IsSuppressed); var project = document.Project; // isLiveSource means build might override a diagnostics, but this method is only used by tooling, so builds aren't relevant @@ -33,7 +32,8 @@ internal static class Diagnostics var result = ArrayBuilder.GetInstance(capacity: diagnostics.Length); foreach (var diagnostic in diagnostics) { - result.AddRange(ProtocolConversions.ConvertDiagnostic(diagnostic, supportsVisualStudioExtensions, project, IsLiveSource, PotentialDuplicate, globalOptionsService)); + if (!diagnostic.IsSuppressed) + result.AddRange(ProtocolConversions.ConvertDiagnostic(diagnostic, supportsVisualStudioExtensions, project, IsLiveSource, PotentialDuplicate, globalOptionsService)); } return result.ToImmutableAndFree(); From e0a72d067b625e62360a7adf91c92334f6a540e0 Mon Sep 17 00:00:00 2001 From: David Barbet Date: Wed, 22 Jan 2025 12:56:53 -0800 Subject: [PATCH 27/76] Revert "Change PR Val builds to be unsigned (#76358)" This reverts commit 2eca5b28c9dd60e09fe4ebdc8544b9efce18d713, reversing changes made to fe3a243bd58966b3e683c9d038321ddb498ff043. --- azure-pipelines-pr-validation.yml | 2 -- eng/Signing.props | 15 --------------- 2 files changed, 17 deletions(-) diff --git a/azure-pipelines-pr-validation.yml b/azure-pipelines-pr-validation.yml index 2b8394f1b5d82..5399ec92521dc 100644 --- a/azure-pipelines-pr-validation.yml +++ b/azure-pipelines-pr-validation.yml @@ -33,8 +33,6 @@ variables: value: false - name: Codeql.SkipTaskAutoInjection value: true - - name: SignType - value: '' # To retrieve OptProf data we need to authenticate to the VS drop storage. # If the pipeline is running in DevDiv, the account has access to the VS drop storage. diff --git a/eng/Signing.props b/eng/Signing.props index 0bda27d7aa9f1..f1d94e766f317 100644 --- a/eng/Signing.props +++ b/eng/Signing.props @@ -61,19 +61,4 @@ - - - - - - - - - - true - - - From c9185a0af0779957466b6720ecb4ac0fd6a7428f Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Wed, 22 Jan 2025 16:32:32 -0800 Subject: [PATCH 28/76] Update formatOnType handler to support formatting on NewLine --- .../Formatting/FormatDocumentOnTypeHandler.cs | 13 +- .../Formatting/FormatDocumentOnTypeTests.cs | 127 ++++++++++++------ 2 files changed, 94 insertions(+), 46 deletions(-) diff --git a/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs b/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs index e6e6df6215855..fcc61833a3598 100644 --- a/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs +++ b/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs @@ -44,13 +44,13 @@ public FormatDocumentOnTypeHandler(IGlobalOptionService globalOptions) if (document is null) return null; - var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false); - - if (string.IsNullOrEmpty(request.Character) || SyntaxFacts.IsNewLine(request.Character[0])) + if (string.IsNullOrEmpty(request.Character)) { return []; } + var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false); + var formattingService = document.Project.Services.GetRequiredService(); var documentSyntax = await ParsedDocument.CreateAsync(document, cancellationToken).ConfigureAwait(false); @@ -72,6 +72,13 @@ public FormatDocumentOnTypeHandler(IGlobalOptionService globalOptions) return []; } + if (SyntaxFacts.IsNewLine(request.Character[0])) + { + // When formatting after a newline is pressed, the cursor line will be blank and we do + // not want to remove the whitespace indentation from it. + textChanges = textChanges.WhereAsArray(change => !change.Span.Contains(position)); + } + return [.. textChanges.Select(change => ProtocolConversions.TextChangeToTextEdit(change, documentSyntax.Text))]; } } diff --git a/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs b/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs index 1ee3fbc732ffe..90e569d619cdf 100644 --- a/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs +++ b/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs @@ -2,8 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -#nullable disable - +using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Threading; using System.Threading.Tasks; @@ -24,65 +23,107 @@ public FormatDocumentOnTypeTests(ITestOutputHelper testOutputHelper) : base(test public async Task TestFormatDocumentOnTypeAsync(bool mutatingLspWorkspace) { var markup = -@"class A -{ - void M() - { - if (true) - {{|type:|} - } -}"; + """ + class A + { + void M() + { + if (true) + {{|type:|} + } + } + """; var expected = -@"class A -{ - void M() - { - if (true) - { - } -}"; + """ + class A + { + void M() + { + if (true) + { + } + } + """; await using var testLspServer = await CreateTestLspServerAsync(markup, mutatingLspWorkspace); var characterTyped = ";"; var locationTyped = testLspServer.GetLocations("type").Single(); - var documentText = await testLspServer.GetDocumentTextAsync(locationTyped.Uri); - - var results = await RunFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped); - var actualText = ApplyTextEdits(results, documentText); - Assert.Equal(expected, actualText); + await AssertFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped, expected); } [Theory, CombinatorialData] public async Task TestFormatDocumentOnType_UseTabsAsync(bool mutatingLspWorkspace) { var markup = -@"class A -{ - void M() - { - if (true) - {{|type:|} - } -}"; + """ + class A + { + void M() + { + if (true) + {{|type:|} + } + } + """; var expected = -@"class A -{ - void M() - { - if (true) - { - } -}"; + """ + class A + { + void M() + { + if (true) + { + } + } + """; await using var testLspServer = await CreateTestLspServerAsync(markup, mutatingLspWorkspace); var characterTyped = ";"; var locationTyped = testLspServer.GetLocations("type").Single(); - var documentText = await testLspServer.GetDocumentTextAsync(locationTyped.Uri); + await AssertFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped, expected, insertSpaces: false, tabSize: 4); + } - var results = await RunFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped, insertSpaces: false, tabSize: 4); + [Theory, CombinatorialData] + public async Task TestFormatDocumentOnType_NewLine(bool mutatingLspWorkspace) + { + var markup = + """ + class A + { + void M() { + {|type:|} + } + } + """; + var expected = + """ + class A + { + void M() + { + + } + } + """; + await using var testLspServer = await CreateTestLspServerAsync(markup, mutatingLspWorkspace); + var characterTyped = "\n"; + var locationTyped = testLspServer.GetLocations("type").Single(); + await AssertFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped, expected); + } + + private static async Task AssertFormatDocumentOnTypeAsync( + TestLspServer testLspServer, + string characterTyped, + LSP.Location locationTyped, + [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expectedText, + bool insertSpaces = true, + int tabSize = 4) + { + var documentText = await testLspServer.GetDocumentTextAsync(locationTyped.Uri); + var results = await RunFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped, insertSpaces, tabSize); var actualText = ApplyTextEdits(results, documentText); - Assert.Equal(expected, actualText); + Assert.Equal(expectedText, actualText); } - private static async Task RunFormatDocumentOnTypeAsync( + private static async Task RunFormatDocumentOnTypeAsync( TestLspServer testLspServer, string characterTyped, LSP.Location locationTyped, From 3e87bdc6103ddd6852be2bf9d29d06ddeac7e57e Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Wed, 22 Jan 2025 17:25:01 -0800 Subject: [PATCH 29/76] Review feedback --- .../Formatting/FormatDocumentOnTypeHandler.cs | 29 +++++++++++++++++-- .../Formatting/FormatDocumentOnTypeTests.cs | 17 +++-------- 2 files changed, 30 insertions(+), 16 deletions(-) diff --git a/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs b/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs index fcc61833a3598..ea99a0a4c0e45 100644 --- a/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs +++ b/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs @@ -74,9 +74,32 @@ public FormatDocumentOnTypeHandler(IGlobalOptionService globalOptions) if (SyntaxFacts.IsNewLine(request.Character[0])) { - // When formatting after a newline is pressed, the cursor line will be blank and we do - // not want to remove the whitespace indentation from it. - textChanges = textChanges.WhereAsArray(change => !change.Span.Contains(position)); + // When formatting after a newline is pressed, the cursor line will be all whitespace + // and we do not want to remove the indentation from it. + // + // Take the following example of pressing enter after an opening brace. + // + // ``` + // public void M() {||} + // ``` + // + // The editor moves the cursor to the next line and uses it's languageconfig to add + // the appropriate level of indentation. + // + // ``` + // public void M() { + // || + // } + // ``` + // + // At this point `formatOnType` is called. The formatting service will generate two + // text changes. The first moves the opening brace to the following line with proper + // indentation. The second removes the whitespace from the cursor line. + // + // Letting the second change go through would be a bad experience for the user as they + // will now be responsible for adding back the proper indentation. + + textChanges = textChanges.WhereAsArray(static (change, position) => !change.Span.Contains(position), position); } return [.. textChanges.Select(change => ProtocolConversions.TextChangeToTextEdit(change, documentSyntax.Text))]; diff --git a/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs b/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs index 90e569d619cdf..4540faebc839f 100644 --- a/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs +++ b/src/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs @@ -118,23 +118,14 @@ private static async Task AssertFormatDocumentOnTypeAsync( int tabSize = 4) { var documentText = await testLspServer.GetDocumentTextAsync(locationTyped.Uri); - var results = await RunFormatDocumentOnTypeAsync(testLspServer, characterTyped, locationTyped, insertSpaces, tabSize); + var results = await testLspServer.ExecuteRequestAsync( + LSP.Methods.TextDocumentOnTypeFormattingName, + CreateDocumentOnTypeFormattingParams(characterTyped, locationTyped, insertSpaces, tabSize), + CancellationToken.None); var actualText = ApplyTextEdits(results, documentText); Assert.Equal(expectedText, actualText); } - private static async Task RunFormatDocumentOnTypeAsync( - TestLspServer testLspServer, - string characterTyped, - LSP.Location locationTyped, - bool insertSpaces = true, - int tabSize = 4) - { - return await testLspServer.ExecuteRequestAsync(LSP.Methods.TextDocumentOnTypeFormattingName, - CreateDocumentOnTypeFormattingParams( - characterTyped, locationTyped, insertSpaces, tabSize), CancellationToken.None); - } - private static LSP.DocumentOnTypeFormattingParams CreateDocumentOnTypeFormattingParams( string characterTyped, LSP.Location locationTyped, From 05dbe1c92d0f5bae4bfff6d44bbdb52bcc541845 Mon Sep 17 00:00:00 2001 From: Joey Robichaud Date: Wed, 22 Jan 2025 17:50:45 -0800 Subject: [PATCH 30/76] Update comment --- .../Formatting/FormatDocumentOnTypeHandler.cs | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs b/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs index ea99a0a4c0e45..f2191c061bc9f 100644 --- a/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs +++ b/src/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs @@ -80,21 +80,22 @@ public FormatDocumentOnTypeHandler(IGlobalOptionService globalOptions) // Take the following example of pressing enter after an opening brace. // // ``` - // public void M() {||} + // public void M() {||} // ``` // // The editor moves the cursor to the next line and uses it's languageconfig to add // the appropriate level of indentation. // // ``` - // public void M() { - // || - // } + // public void M() { + // || + // } // ``` // // At this point `formatOnType` is called. The formatting service will generate two - // text changes. The first moves the opening brace to the following line with proper - // indentation. The second removes the whitespace from the cursor line. + // text changes. The first moves the opening brace to a new line with proper + // indentation. The second removes the whitespace from the cursor line and rewrites + // the indentation prior to the closing brace. // // Letting the second change go through would be a bad experience for the user as they // will now be responsible for adding back the proper indentation. From 55e8ff7932de945261272689900f2a10f59f2255 Mon Sep 17 00:00:00 2001 From: Todd Grunke Date: Thu, 23 Jan 2025 08:16:55 -0800 Subject: [PATCH 31/76] Reduce work in ConversionsBase.AddUserDefinedConversionsToExplicitCandidateSet (#76835) * Reduce work in ConversionsBase.AddUserDefinedConversionsToExplicitCandidateSet The ArrayBuilder usage in this method is showing up slightly in speedometer CPU profiles (0.1%) but more heavily in local profiles I've taken using a much larger version of the file than what the speedometer tests use (2.6%) This method is called quite often and the (isExplicit && isChecked) check seems to not hit very often (specifically, never in my testing of opening/simple editing of the file). The usage of the pool and populating the array builder aren't necessary unless that case is hit, so I've reshuffled the code around a bit to avoid that. --- .../UserDefinedExplicitConversions.cs | 26 +++++++++---------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs index caa4fa8c59f79..32db5df21b27e 100644 --- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs +++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs @@ -222,29 +222,28 @@ private void AddUserDefinedConversionsToExplicitCandidateSet( isExplicit ? (isChecked ? WellKnownMemberNames.CheckedExplicitConversionName : WellKnownMemberNames.ExplicitConversionName) : WellKnownMemberNames.ImplicitConversionName, operators); - var candidates = ArrayBuilder.GetInstance(operators.Count); - candidates.AddRange(operators); - if (isExplicit && isChecked) { - var operators2 = ArrayBuilder.GetInstance(); - declaringType.AddOperators(WellKnownMemberNames.ExplicitConversionName, operators2); - // Add regular operators as well. if (operators.IsEmpty) { - candidates.AddRange(operators2); + declaringType.AddOperators(WellKnownMemberNames.ExplicitConversionName, operators); } else { + var originalOperatorCount = operators.Count; + + var operators2 = ArrayBuilder.GetInstance(); + declaringType.AddOperators(WellKnownMemberNames.ExplicitConversionName, operators2); + foreach (MethodSymbol op2 in operators2) { // Drop operators that have a match among the checked ones. bool add = true; - foreach (MethodSymbol op in operators) + for (var i = 0; i < originalOperatorCount; i++) { - if (SourceMemberContainerTypeSymbol.DoOperatorsPair(op, op2)) + if (SourceMemberContainerTypeSymbol.DoOperatorsPair(operators[i], op2)) { add = false; break; @@ -253,15 +252,15 @@ private void AddUserDefinedConversionsToExplicitCandidateSet( if (add) { - candidates.Add(op2); + operators.Add(op2); } } - } - operators2.Free(); + operators2.Free(); + } } - foreach (MethodSymbol op in candidates) + foreach (MethodSymbol op in operators) { // We might have a bad operator and be in an error recovery situation. Ignore it. if (op.ReturnsVoid || op.ParameterCount != 1 || op.ReturnType.TypeKind == TypeKind.Error) @@ -365,7 +364,6 @@ private void AddUserDefinedConversionsToExplicitCandidateSet( } operators.Free(); - candidates.Free(); } private TypeSymbol MostSpecificSourceTypeForExplicitUserDefinedConversion( From 9739676000baa892d5ce26f89a16d96de22858f1 Mon Sep 17 00:00:00 2001 From: Jan Jones Date: Thu, 23 Jan 2025 17:19:38 +0100 Subject: [PATCH 32/76] Add feature status of Partial Events and Constructors (#76879) * Add feature status of Partial Events and Constructors * Link champion issue --- docs/Language Feature Status.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md index 014b3e5977d38..d35426981d164 100644 --- a/docs/Language Feature Status.md +++ b/docs/Language Feature Status.md @@ -10,6 +10,7 @@ efforts behind them. | Feature | Branch | State | Developer | Reviewer | IDE Buddy | LDM Champ | | ------- | ------ | ----- | --------- | -------- | --------- | --------- | +| [Partial Events and Constructors](https://github.com/dotnet/csharplang/issues/9058) | [features/PartialEventsCtors](https://github.com/dotnet/roslyn/tree/features/PartialEventsCtors) | [In Progress](https://github.com/dotnet/roslyn/issues/76859) | [jjonescz](https://github.com/jjonescz) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | | | | Runtime Async | [features/runtime-async](https://github.com/dotnet/roslyn/tree/features/runtime-async) | [In Progress](https://github.com/dotnet/roslyn/issues/75960) | [333fred](https://github.com/333fred) | [jcouv](https://github.com/jcouv), [RikkiGibson](https://github.com/RikkiGibson) | | | | [Simple lambda parameters with modifiers](https://github.com/dotnet/csharplang/blob/main/proposals/simple-lambda-parameters-with-modifiers.md) | [PR](https://github.com/dotnet/roslyn/pull/75400) | [In Progress](https://github.com/dotnet/roslyn/issues/76298) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jjonescz](https://github.com/jjonescz), [cston](https://github.com/cston) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | | [Null-conditional assignment](https://github.com/dotnet/csharplang/issues/6045) | [null-conditional-assignment](https://github.com/dotnet/roslyn/tree/features/null-conditional-assignment) | [In Progress](https://github.com/dotnet/roslyn/issues/75554) | [RikkiGibson](https://github.com/RikkiGibson) | [cston](https://github.com/cston), [jjonescz](https://github.com/jjonescz) | TBD | [RikkiGibson](https://github.com/RikkiGibson) | From d5cf1ea6b64729d9d2133c391d558f2ee8efc823 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?= Date: Thu, 23 Jan 2025 09:15:49 -0800 Subject: [PATCH 33/76] Enc logging (#76042) --- .../EditAndContinueLanguageService.cs | 26 +-- ...crosoft.CodeAnalysis.EditorFeatures.csproj | 2 + .../CSharpEditAndContinueAnalyzer.cs | 16 +- .../CSharpEditAndContinueAnalyzerTests.cs | 13 +- .../CSharpEditAndContinueTestVerifier.cs | 6 +- .../Helpers/EditAndContinueValidation.cs | 3 +- .../Helpers/EditingTestBase.cs | 12 +- .../EditAndContinue/StatementMatchingTests.cs | 2 + .../AbstractEditAndContinueAnalyzer.cs | 43 +++-- .../EditAndContinue/CommittedSolution.cs | 50 +++--- .../EditAndContinue/DebuggingSession.cs | 36 +++-- .../EditAndContinue/DebuggingSessionId.cs | 6 +- .../EditAndContinueDocumentAnalysesCache.cs | 5 +- .../EditAndContinue/EditAndContinueService.cs | 39 +++-- .../Portable/EditAndContinue/EditSession.cs | 55 ++++--- .../IEditAndContinueAnalyzer.cs | 1 + .../IEditAndContinueLogReporter.cs | 13 ++ .../EditAndContinue/SolutionUpdate.cs | 19 +-- .../Core/Portable/EditAndContinue/TraceLog.cs | 150 ++++-------------- .../EditAndContinue/Utilities/Extensions.cs | 6 +- .../EditAndContinueWorkspaceServiceTests.cs | 23 +-- .../EditSessionActiveStatementsTests.cs | 4 + .../Test/EditAndContinue/TraceLogTests.cs | 39 ----- .../EditAndContinueTestVerifier.cs | 25 ++- .../VisualBasicEditAndContinueAnalyzer.vb | 21 +-- .../Helpers/EditingTestBase.vb | 8 +- .../VisualBasicEditAndContinueTestVerifier.vb | 19 +-- ...VisualBasicEditAndContinueAnalyzerTests.vb | 5 +- .../Host/RemoteWorkspace.SolutionCreator.cs | 1 - ...soft.CodeAnalysis.Remote.ServiceHub.csproj | 1 + .../EditAndContinueLogReporter.cs | 64 ++++++++ .../EditAndContinue}/HotReloadLoggerProxy.cs | 0 32 files changed, 338 insertions(+), 375 deletions(-) create mode 100644 src/Features/Core/Portable/EditAndContinue/IEditAndContinueLogReporter.cs delete mode 100644 src/Features/Test/EditAndContinue/TraceLogTests.cs create mode 100644 src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/EditAndContinueLogReporter.cs rename src/{EditorFeatures/Core/EditAndContinue/Contracts => Workspaces/Remote/ServiceHub/Services/EditAndContinue}/HotReloadLoggerProxy.cs (100%) diff --git a/src/EditorFeatures/Core/EditAndContinue/EditAndContinueLanguageService.cs b/src/EditorFeatures/Core/EditAndContinue/EditAndContinueLanguageService.cs index c4d3dd98990c0..74948a69c5ad0 100644 --- a/src/EditorFeatures/Core/EditAndContinue/EditAndContinueLanguageService.cs +++ b/src/EditorFeatures/Core/EditAndContinue/EditAndContinueLanguageService.cs @@ -9,14 +9,12 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; -using Microsoft.CodeAnalysis.BrokeredServices; using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.ErrorReporting; using Microsoft.CodeAnalysis.Host; using Microsoft.CodeAnalysis.Host.Mef; using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Shared.Extensions; -using Microsoft.CodeAnalysis.Shared.TestHooks; using Microsoft.VisualStudio.Debugger.Contracts.HotReload; using Roslyn.Utilities; @@ -31,13 +29,12 @@ namespace Microsoft.CodeAnalysis.EditAndContinue; [method: ImportingConstructor] [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] internal sealed class EditAndContinueLanguageService( - IServiceBrokerProvider serviceBrokerProvider, EditAndContinueSessionState sessionState, Lazy workspaceProvider, Lazy debuggerService, PdbMatchingSourceTextProvider sourceTextProvider, - IDiagnosticsRefresher diagnosticRefresher, - IAsynchronousOperationListenerProvider listenerProvider) : IManagedHotReloadLanguageService2, IEditAndContinueSolutionProvider + IEditAndContinueLogReporter logReporter, + IDiagnosticsRefresher diagnosticRefresher) : IManagedHotReloadLanguageService2, IEditAndContinueSolutionProvider { private sealed class NoSessionException : InvalidOperationException { @@ -49,9 +46,6 @@ public NoSessionException() } } - private readonly IAsynchronousOperationListener _asyncListener = listenerProvider.GetListener(FeatureAttribute.EditAndContinue); - private readonly HotReloadLoggerProxy _logger = new(serviceBrokerProvider.ServiceBroker); - private bool _disabled; private RemoteDebuggingSessionProxy? _debuggingSession; @@ -94,11 +88,7 @@ private IActiveStatementTrackingService GetActiveStatementTrackingService() internal void Disable(Exception e) { _disabled = true; - - var token = _asyncListener.BeginAsyncOperation(nameof(EditAndContinueLanguageService) + ".LogToOutput"); - - _ = _logger.LogAsync(new HotReloadLogMessage(HotReloadVerbosity.Diagnostic, e.ToString(), errorLevel: HotReloadDiagnosticErrorLevel.Error), CancellationToken.None).AsTask() - .ReportNonFatalErrorAsync().CompletesAsyncOperation(token); + logReporter.Report(e.ToString(), LogMessageSeverity.Error); } private void UpdateApplyChangesDiagnostics(ImmutableArray diagnostics) @@ -265,7 +255,7 @@ public async ValueTask UpdateBaselinesAsync(ImmutableArray projectPaths, } _committedDesignTimeSolution = currentDesignTimeSolution; - var projectIds = await GetProjectIdsAsync(projectPaths, currentCompileTimeSolution, cancellationToken).ConfigureAwait(false); + var projectIds = GetProjectIds(projectPaths, currentCompileTimeSolution); try { @@ -281,7 +271,7 @@ public async ValueTask UpdateBaselinesAsync(ImmutableArray projectPaths, } } - private async ValueTask> GetProjectIdsAsync(ImmutableArray projectPaths, Solution solution, CancellationToken cancellationToken) + private ImmutableArray GetProjectIds(ImmutableArray projectPaths, Solution solution) { using var _ = ArrayBuilder.GetInstance(out var projectIds); foreach (var path in projectPaths) @@ -293,11 +283,7 @@ private async ValueTask> GetProjectIdsAsync(ImmutableA } else { - await _logger.LogAsync(new HotReloadLogMessage( - HotReloadVerbosity.Diagnostic, - $"Project with path '{path}' not found in the current solution.", - errorLevel: HotReloadDiagnosticErrorLevel.Warning), - cancellationToken).ConfigureAwait(false); + logReporter.Report($"Project with path '{path}' not found in the current solution.", LogMessageSeverity.Info); } } diff --git a/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj b/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj index 0d1bf87e852d7..2ffdb061e7ab2 100644 --- a/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj +++ b/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj @@ -36,6 +36,8 @@ + + diff --git a/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs b/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs index 188db75a521b6..b15aa6882b6f9 100644 --- a/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs +++ b/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs @@ -15,8 +15,6 @@ using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Differencing; using Microsoft.CodeAnalysis.EditAndContinue; -using Microsoft.CodeAnalysis.Formatting; -using Microsoft.CodeAnalysis.Host; using Microsoft.CodeAnalysis.Host.Mef; using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Shared.Collections; @@ -26,17 +24,11 @@ namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue; -internal sealed class CSharpEditAndContinueAnalyzer(Action? testFaultInjector = null) : AbstractEditAndContinueAnalyzer(testFaultInjector) +[ExportLanguageService(typeof(IEditAndContinueAnalyzer), LanguageNames.CSharp), Shared] +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed class CSharpEditAndContinueAnalyzer() : AbstractEditAndContinueAnalyzer { - [ExportLanguageServiceFactory(typeof(IEditAndContinueAnalyzer), LanguageNames.CSharp), Shared] - [method: ImportingConstructor] - [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - internal sealed class Factory() : ILanguageServiceFactory - { - public ILanguageService CreateLanguageService(HostLanguageServices languageServices) - => new CSharpEditAndContinueAnalyzer(testFaultInjector: null); - } - #region Syntax Analysis private enum BlockPart diff --git a/src/Features/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs b/src/Features/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs index 292dd30d98dc6..84f7c5020d8ae 100644 --- a/src/Features/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs +++ b/src/Features/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs @@ -122,10 +122,11 @@ private static async Task AnalyzeDocumentAsync( EditAndContinueCapabilities capabilities = EditAndContinueTestVerifier.Net5RuntimeCapabilities, ImmutableArray newActiveStatementSpans = default) { - var analyzer = new CSharpEditAndContinueAnalyzer(); + var analyzer = oldProject.Services.GetRequiredService(); var baseActiveStatements = AsyncLazy.Create(activeStatementMap ?? ActiveStatementsMap.Empty); var lazyCapabilities = AsyncLazy.Create(capabilities); - return await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, newActiveStatementSpans.NullToEmpty(), lazyCapabilities, CancellationToken.None); + var log = new TraceLog("Test"); + return await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, newActiveStatementSpans.NullToEmpty(), lazyCapabilities, log, CancellationToken.None); } #endregion @@ -749,15 +750,17 @@ public async Task AnalyzeDocumentAsync_InternalError(bool outOfMemory) var baseActiveStatements = AsyncLazy.Create(ActiveStatementsMap.Empty); var capabilities = AsyncLazy.Create(EditAndContinueTestVerifier.Net5RuntimeCapabilities); - var analyzer = new CSharpEditAndContinueAnalyzer(node => + var analyzer = Assert.IsType(oldProject.Services.GetRequiredService()); + analyzer.GetTestAccessor().FaultInjector = node => { if (node is CompilationUnitSyntax) { throw outOfMemory ? new OutOfMemoryException() : new NullReferenceException("NullRef!"); } - }); + }; - var result = await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, [], capabilities, CancellationToken.None); + var log = new TraceLog("Test"); + var result = await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, [], capabilities, log, CancellationToken.None); var expectedDiagnostic = outOfMemory ? $"ENC0089: {string.Format(FeaturesResources.Modifying_source_file_0_requires_restarting_the_application_because_the_file_is_too_big, filePath)}" diff --git a/src/Features/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestVerifier.cs b/src/Features/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestVerifier.cs index 2c38995e0dce1..8dcdd79f7b572 100644 --- a/src/Features/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestVerifier.cs +++ b/src/Features/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestVerifier.cs @@ -6,17 +6,13 @@ using System.Collections.Immutable; using Microsoft.CodeAnalysis.CSharp.Symbols; using Microsoft.CodeAnalysis.Differencing; -using Microsoft.CodeAnalysis.EditAndContinue; using Microsoft.CodeAnalysis.EditAndContinue.UnitTests; using Xunit; namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests; -internal sealed class CSharpEditAndContinueTestVerifier(Action? faultInjector = null) : EditAndContinueTestVerifier +internal sealed class CSharpEditAndContinueTestVerifier(Action? faultInjector = null) : EditAndContinueTestVerifier(faultInjector) { - private readonly CSharpEditAndContinueAnalyzer _analyzer = new(faultInjector); - - public override AbstractEditAndContinueAnalyzer Analyzer => _analyzer; public override string LanguageName => LanguageNames.CSharp; public override string ProjectFileExtension => ".csproj"; public override TreeComparer TopSyntaxComparer => SyntaxComparer.TopLevel; diff --git a/src/Features/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs b/src/Features/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs index 252a5c1ec6764..0d8f89d47c2fa 100644 --- a/src/Features/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs +++ b/src/Features/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs @@ -2,9 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using Microsoft.CodeAnalysis.Differencing; -using Microsoft.CodeAnalysis.EditAndContinue; using Microsoft.CodeAnalysis.Contracts.EditAndContinue; +using Microsoft.CodeAnalysis.EditAndContinue; using Microsoft.CodeAnalysis.EditAndContinue.UnitTests; using Roslyn.Test.Utilities; using Xunit; diff --git a/src/Features/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs b/src/Features/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs index 89fe647d5c4fd..778bff54e0d09 100644 --- a/src/Features/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs +++ b/src/Features/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs @@ -5,14 +5,16 @@ using System; using System.Collections.Generic; using System.IO; +using System.Linq; +using Microsoft.CodeAnalysis.Contracts.EditAndContinue; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.CSharp.Test.Utilities; using Microsoft.CodeAnalysis.CSharp.UnitTests; using Microsoft.CodeAnalysis.Differencing; using Microsoft.CodeAnalysis.EditAndContinue; -using Microsoft.CodeAnalysis.Contracts.EditAndContinue; using Microsoft.CodeAnalysis.EditAndContinue.UnitTests; using Microsoft.CodeAnalysis.Emit; +using Microsoft.CodeAnalysis.Host.Mef; using Microsoft.CodeAnalysis.Test.Utilities; using Microsoft.CodeAnalysis.Text; using Roslyn.Utilities; @@ -27,11 +29,6 @@ public abstract class EditingTestBase : CSharpTestBase namespace System.Runtime.CompilerServices { class CreateNewOnMetadataUpdateAttribute : Attribute {} } "; - internal static CSharpEditAndContinueAnalyzer CreateAnalyzer() - { - return new CSharpEditAndContinueAnalyzer(testFaultInjector: null); - } - internal enum MethodKind { Regular, @@ -184,7 +181,8 @@ internal static Match GetMethodMatch(string src1, string src2, Metho internal static IEnumerable> GetMethodMatches(string src1, string src2, MethodKind kind = MethodKind.Regular) { var methodMatch = GetMethodMatch(src1, src2, kind); - return EditAndContinueTestVerifier.GetMethodMatches(CreateAnalyzer(), methodMatch); + var analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector: null, LanguageNames.CSharp); + return EditAndContinueTestVerifier.GetMethodMatches(analyzer, methodMatch); } public static MatchingPairs ToMatchingPairs(Match match) diff --git a/src/Features/CSharpTest/EditAndContinue/StatementMatchingTests.cs b/src/Features/CSharpTest/EditAndContinue/StatementMatchingTests.cs index 6e6ebef35347a..cc2bd04c9dc14 100644 --- a/src/Features/CSharpTest/EditAndContinue/StatementMatchingTests.cs +++ b/src/Features/CSharpTest/EditAndContinue/StatementMatchingTests.cs @@ -7,11 +7,13 @@ using System.Collections.Generic; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.EditAndContinue.UnitTests; +using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; using Xunit; namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests; +[UseExportProvider] public class StatementMatchingTests : EditingTestBase { #region Known Matches diff --git a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs index 0f5a03443dc94..0eb3caab26dfd 100644 --- a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs +++ b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs @@ -69,15 +69,7 @@ internal abstract class AbstractEditAndContinueAnalyzer : IEditAndContinueAnalyz SymbolDisplayMiscellaneousOptions.UseSpecialTypes); // used by tests to validate correct handlign of unexpected exceptions - private readonly Action? _testFaultInjector; - - protected AbstractEditAndContinueAnalyzer(Action? testFaultInjector) - { - _testFaultInjector = testFaultInjector; - } - - private static TraceLog Log - => EditAndContinueService.AnalysisLog; + private Action? _testFaultInjector; internal abstract bool ExperimentalFeaturesEnabled(SyntaxTree tree); @@ -516,6 +508,7 @@ public async Task AnalyzeDocumentAsync( Document newDocument, ImmutableArray newActiveStatementSpans, AsyncLazy lazyCapabilities, + TraceLog log, CancellationToken cancellationToken) { var filePath = newDocument.FilePath; @@ -573,7 +566,7 @@ public async Task AnalyzeDocumentAsync( { // Bail, since we can't do syntax diffing on broken trees (it would not produce useful results anyways). // If we needed to do so for some reason, we'd need to harden the syntax tree comparers. - Log.Write("Syntax errors found in '{0}'", filePath); + log.Write($"Syntax errors found in '{filePath}'"); return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, [], syntaxError, analysisStopwatch.Elapsed, hasChanges); } @@ -584,7 +577,7 @@ public async Task AnalyzeDocumentAsync( // a) comparing texts is cheaper than diffing trees // b) we need to ignore errors in unchanged documents - Log.Write("Document unchanged: '{0}'", filePath); + log.Write($"Document unchanged: '{filePath}'"); return DocumentAnalysisResults.Unchanged(newDocument.Id, filePath, analysisStopwatch.Elapsed); } @@ -592,8 +585,7 @@ public async Task AnalyzeDocumentAsync( // These features may not be handled well by the analysis below. if (ExperimentalFeaturesEnabled(newTree)) { - Log.Write("Experimental features enabled in '{0}'", filePath); - + log.Write($"Experimental features enabled in '{filePath}'"); return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, [new RudeEditDiagnostic(RudeEditKind.ExperimentalFeaturesEnabled, default)], syntaxError: null, analysisStopwatch.Elapsed, hasChanges); } @@ -667,7 +659,7 @@ public async Task AnalyzeDocumentAsync( cancellationToken.ThrowIfCancellationRequested(); - AnalyzeUnchangedActiveMemberBodies(diagnostics, syntacticEdits.Match, newText, oldActiveStatements, newActiveStatementSpans, newActiveStatements, newExceptionRegions, cancellationToken); + AnalyzeUnchangedActiveMemberBodies(diagnostics, syntacticEdits.Match, newText, oldActiveStatements, newActiveStatementSpans, newActiveStatements, newExceptionRegions, log, cancellationToken); Debug.Assert(newActiveStatements.All(a => a != null)); if (!diagnostics.IsEmpty) @@ -676,7 +668,7 @@ public async Task AnalyzeDocumentAsync( } else { - Log.Write("Capabilities required by '{0}': {1}", filePath, capabilities.GrantedCapabilities); + log.Write($"Capabilities required by '{filePath}': {capabilities.GrantedCapabilities}"); } var hasBlockingRudeEdits = diagnostics.HasBlockingRudeEdits(); @@ -710,7 +702,7 @@ public async Task AnalyzeDocumentAsync( return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, [diagnostic], syntaxError: null, analysisStopwatch.Elapsed, hasChanges); } - static void LogRudeEdits(ArrayBuilder diagnostics, SourceText text, string filePath) + void LogRudeEdits(ArrayBuilder diagnostics, SourceText text, string filePath) { foreach (var diagnostic in diagnostics) { @@ -728,7 +720,7 @@ static void LogRudeEdits(ArrayBuilder diagnostics, SourceTex lineText = null; } - Log.Write("Rude edit {0}:{1} '{2}' line {3}: '{4}'", diagnostic.Kind, diagnostic.SyntaxKind, filePath, lineNumber, lineText); + log.Write($"Rude edit {diagnostic.Kind}:{diagnostic.SyntaxKind} '{filePath}' line {lineNumber}: '{lineText}'"); } } } @@ -786,6 +778,7 @@ private void AnalyzeUnchangedActiveMemberBodies( ImmutableArray newActiveStatementSpans, [In, Out] ImmutableArray.Builder newActiveStatements, [In, Out] ImmutableArray>.Builder newExceptionRegions, + TraceLog log, CancellationToken cancellationToken) { Debug.Assert(!newActiveStatementSpans.IsDefault); @@ -819,7 +812,7 @@ private void AnalyzeUnchangedActiveMemberBodies( // Guard against invalid active statement spans (in case PDB was somehow out of sync with the source). if (oldBody == null || newBody == null) { - Log.Write("Invalid active statement span: [{0}..{1})", oldStatementSpan.Start, oldStatementSpan.End); + log.Write($"Invalid active statement span: {oldStatementSpan}", LogMessageSeverity.Warning); continue; } @@ -872,7 +865,7 @@ private void AnalyzeUnchangedActiveMemberBodies( } else { - Log.Write("Invalid active statement span: [{0}..{1})", oldStatementSpan.Start, oldStatementSpan.End); + log.Write($"Invalid active statement span: {oldStatementSpan}", LogMessageSeverity.Warning); } // we were not able to determine the active statement location (PDB data might be invalid) @@ -6779,19 +6772,23 @@ private static bool HasGetHashCodeSignature(IMethodSymbol method) internal TestAccessor GetTestAccessor() => new(this); - internal readonly struct TestAccessor(AbstractEditAndContinueAnalyzer abstractEditAndContinueAnalyzer) + internal readonly struct TestAccessor(AbstractEditAndContinueAnalyzer analyzer) { - private readonly AbstractEditAndContinueAnalyzer _abstractEditAndContinueAnalyzer = abstractEditAndContinueAnalyzer; + internal Action? FaultInjector + { + get => analyzer._testFaultInjector; + set => analyzer._testFaultInjector = value; + } internal void ReportTopLevelSyntacticRudeEdits(ArrayBuilder diagnostics, EditScript syntacticEdits, Dictionary editMap) - => _abstractEditAndContinueAnalyzer.ReportTopLevelSyntacticRudeEdits(diagnostics, syntacticEdits, editMap); + => analyzer.ReportTopLevelSyntacticRudeEdits(diagnostics, syntacticEdits, editMap); internal DeclarationBodyMap IncludeLambdaBodyMaps( DeclarationBodyMap bodyMap, ArrayBuilder memberBodyActiveNodes, ref Dictionary? lazyActiveOrMatchedLambdas) { - return _abstractEditAndContinueAnalyzer.IncludeLambdaBodyMaps(bodyMap, memberBodyActiveNodes, ref lazyActiveOrMatchedLambdas); + return analyzer.IncludeLambdaBodyMaps(bodyMap, memberBodyActiveNodes, ref lazyActiveOrMatchedLambdas); } } diff --git a/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs b/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs index 892a63146b2b7..fb8ee80784cd0 100644 --- a/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs +++ b/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs @@ -312,14 +312,15 @@ public bool ContainsDocument(DocumentId documentId) var maybePdbHasDocument = TryReadSourceFileChecksumFromPdb(document, out var requiredChecksum, out var checksumAlgorithm); - var maybeMatchingSourceText = (maybePdbHasDocument == true) ? - await TryGetMatchingSourceTextAsync(sourceText, document.FilePath, currentDocument, _debuggingSession.SourceTextProvider, requiredChecksum, checksumAlgorithm, cancellationToken).ConfigureAwait(false) : default; + var maybeMatchingSourceText = (maybePdbHasDocument == true) + ? await TryGetMatchingSourceTextAsync(_debuggingSession.SessionLog, sourceText, document.FilePath, currentDocument, _debuggingSession.SourceTextProvider, requiredChecksum, checksumAlgorithm, cancellationToken).ConfigureAwait(false) + : default; return (maybeMatchingSourceText, maybePdbHasDocument); } private static async ValueTask> TryGetMatchingSourceTextAsync( - SourceText sourceText, string filePath, Document? currentDocument, IPdbMatchingSourceTextProvider sourceTextProvider, ImmutableArray requiredChecksum, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) + TraceLog log, SourceText sourceText, string filePath, Document? currentDocument, IPdbMatchingSourceTextProvider sourceTextProvider, ImmutableArray requiredChecksum, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) { if (IsMatchingSourceText(sourceText, requiredChecksum, checksumAlgorithm)) { @@ -341,10 +342,11 @@ public bool ContainsDocument(DocumentId documentId) return SourceText.From(text, sourceText.Encoding, checksumAlgorithm); } - return await Task.Run(() => TryGetPdbMatchingSourceTextFromDisk(filePath, sourceText.Encoding, requiredChecksum, checksumAlgorithm), cancellationToken).ConfigureAwait(false); + return await Task.Run(() => TryGetPdbMatchingSourceTextFromDisk(log, filePath, sourceText.Encoding, requiredChecksum, checksumAlgorithm), cancellationToken).ConfigureAwait(false); } internal static async Task>> GetMatchingDocumentsAsync( + TraceLog log, IEnumerable<(Project, IEnumerable)> documentsByProject, Func compilationOutputsProvider, IPdbMatchingSourceTextProvider sourceTextProvider, @@ -363,7 +365,7 @@ internal static async Task>> return []; } - using var debugInfoReaderProvider = GetMethodDebugInfoReader(compilationOutputsProvider(project), project.Name); + using var debugInfoReaderProvider = GetMethodDebugInfoReader(log, compilationOutputsProvider(project), project.Name); if (debugInfoReaderProvider == null) { return []; @@ -386,8 +388,8 @@ internal static async Task>> // TODO: https://github.com/dotnet/roslyn/issues/51993 // avoid rereading the file in common case - the workspace should create source texts with the right checksum algorithm and encoding - if (TryReadSourceFileChecksumFromPdb(debugInfoReader, sourceFilePath, out var requiredChecksum, out var checksumAlgorithm) == true && - await TryGetMatchingSourceTextAsync(sourceText, sourceFilePath, currentDocument: null, sourceTextProvider, requiredChecksum, checksumAlgorithm, cancellationToken).ConfigureAwait(false) is { HasValue: true, Value: not null }) + if (TryReadSourceFileChecksumFromPdb(log, debugInfoReader, sourceFilePath, out var requiredChecksum, out var checksumAlgorithm) == true && + await TryGetMatchingSourceTextAsync(log, sourceText, sourceFilePath, currentDocument: null, sourceTextProvider, requiredChecksum, checksumAlgorithm, cancellationToken).ConfigureAwait(false) is { HasValue: true, Value: not null }) { return documentState.Id; } @@ -404,7 +406,7 @@ await TryGetMatchingSourceTextAsync(sourceText, sourceFilePath, currentDocument: return documentIdArrays.SelectMany(ids => ids.WhereNotNull()).Select(id => KeyValuePairUtil.Create(id, DocumentState.MatchesBuildOutput)); } - private static DebugInformationReaderProvider? GetMethodDebugInfoReader(CompilationOutputs compilationOutputs, string projectName) + private static DebugInformationReaderProvider? GetMethodDebugInfoReader(TraceLog log, CompilationOutputs compilationOutputs, string projectName) { DebugInformationReaderProvider? debugInfoReaderProvider; try @@ -413,14 +415,14 @@ await TryGetMatchingSourceTextAsync(sourceText, sourceFilePath, currentDocument: if (debugInfoReaderProvider == null) { - EditAndContinueService.Log.Write("Source file of project '{0}' doesn't match output PDB: PDB '{1}' (assembly: '{2}') not found", projectName, compilationOutputs.PdbDisplayPath, compilationOutputs.AssemblyDisplayPath); + log.Write($"Source file of project '{projectName}' doesn't match output PDB: PDB '{compilationOutputs.PdbDisplayPath}' (assembly: '{compilationOutputs.AssemblyDisplayPath}') not found", LogMessageSeverity.Warning); } return debugInfoReaderProvider; } catch (Exception e) { - EditAndContinueService.Log.Write("Source file of project '{0}' doesn't match output PDB: error opening PDB '{1}' (assembly: '{2}'): {3}", projectName, compilationOutputs.PdbDisplayPath, compilationOutputs.AssemblyDisplayPath, e.Message); + log.Write($"Source file of project '{projectName}' doesn't match output PDB: error opening PDB '{compilationOutputs.PdbDisplayPath}' (assembly: '{compilationOutputs.AssemblyDisplayPath}'): {e.Message}", LogMessageSeverity.Warning); return null; } } @@ -436,7 +438,12 @@ public void CommitSolution(Solution solution) private static bool IsMatchingSourceText(SourceText sourceText, ImmutableArray requiredChecksum, SourceHashAlgorithm checksumAlgorithm) => checksumAlgorithm == sourceText.ChecksumAlgorithm && sourceText.GetChecksum().SequenceEqual(requiredChecksum); - private static Optional TryGetPdbMatchingSourceTextFromDisk(string sourceFilePath, Encoding? encoding, ImmutableArray requiredChecksum, SourceHashAlgorithm checksumAlgorithm) + private static Optional TryGetPdbMatchingSourceTextFromDisk( + TraceLog log, + string sourceFilePath, + Encoding? encoding, + ImmutableArray requiredChecksum, + SourceHashAlgorithm checksumAlgorithm) { try { @@ -453,14 +460,14 @@ private static bool IsMatchingSourceText(SourceText sourceText, ImmutableArray @@ -491,7 +498,12 @@ private static bool IsMatchingSourceText(SourceText sourceText, ImmutableArray - private static bool? TryReadSourceFileChecksumFromPdb(EditAndContinueMethodDebugInfoReader debugInfoReader, string sourceFilePath, out ImmutableArray checksum, out SourceHashAlgorithm algorithm) + private static bool? TryReadSourceFileChecksumFromPdb( + TraceLog log, + EditAndContinueMethodDebugInfoReader debugInfoReader, + string sourceFilePath, + out ImmutableArray checksum, + out SourceHashAlgorithm algorithm) { checksum = default; algorithm = default; @@ -500,7 +512,7 @@ private static bool IsMatchingSourceText(SourceText sourceText, ImmutableArray _compilationOutputsProvider; - internal readonly IPdbMatchingSourceTextProvider SourceTextProvider; private readonly CancellationTokenSource _cancellationSource = new(); + internal readonly IPdbMatchingSourceTextProvider SourceTextProvider; + + /// + /// Logs debugging session events. + /// + internal readonly TraceLog SessionLog; + + /// + /// Logs EnC analysis events. + /// + internal readonly TraceLog AnalysisLog; + /// /// The current baseline for given project id. /// The baseline is updated when changes are committed at the end of edit session. @@ -93,7 +104,9 @@ internal sealed class DebuggingSession : IDisposable /// Last array of module updates generated during the debugging session. /// Useful for crash dump diagnostics. /// +#pragma warning disable IDE0052 // Remove unread private members private ImmutableArray _lastModuleUpdatesLog; +#pragma warning restore IDE0052 internal DebuggingSession( DebuggingSessionId id, @@ -102,12 +115,16 @@ internal DebuggingSession( Func compilationOutputsProvider, IPdbMatchingSourceTextProvider sourceTextProvider, IEnumerable> initialDocumentStates, + TraceLog sessionLog, + TraceLog analysisLog, bool reportDiagnostics) { - EditAndContinueService.Log.Write($"Debugging session started: #{id}"); + sessionLog.Write($"Debugging session started: #{id}"); _compilationOutputsProvider = compilationOutputsProvider; SourceTextProvider = sourceTextProvider; + SessionLog = sessionLog; + AnalysisLog = analysisLog; _reportTelemetry = ReportTelemetry; _telemetry = new DebuggingSessionTelemetry(solution.SolutionState.SolutionAttributes.TelemetryId); @@ -198,7 +215,7 @@ public void EndSession(out DebuggingSessionTelemetry.Data telemetryData) Dispose(); - EditAndContinueService.Log.Write($"Debugging session ended: #{Id}"); + SessionLog.Write($"Debugging session ended: #{Id}"); } public void BreakStateOrCapabilitiesChanged(bool? inBreakState) @@ -206,7 +223,7 @@ public void BreakStateOrCapabilitiesChanged(bool? inBreakState) internal void RestartEditSession(ImmutableDictionary>? nonRemappableRegions, bool? inBreakState) { - EditAndContinueService.Log.Write($"Edit session restarted (break state: {inBreakState?.ToString() ?? "null"})"); + SessionLog.Write($"Edit session restarted (break state: {inBreakState?.ToString() ?? "null"})"); ThrowIfDisposed(); @@ -321,7 +338,7 @@ bool TryGetBaselinesContainingModuleVersion(Guid moduleId, [NotNullWhen(true)] o baselines.Any(static (b, moduleId) => b.ModuleId == moduleId, moduleId); } - private static unsafe bool TryCreateInitialBaseline( + private unsafe bool TryCreateInitialBaseline( Compilation compilation, CompilationOutputs compilationOutputs, ProjectId projectId, @@ -376,7 +393,7 @@ private static unsafe bool TryCreateInitialBaseline( } catch (Exception e) { - EditAndContinueService.Log.Write("Failed to create baseline for '{0}': {1}", projectId, e.Message); + SessionLog.Write($"Failed to create baseline for '{projectId.DebugName}': {e.Message}", LogMessageSeverity.Error); var descriptor = EditAndContinueDiagnosticDescriptors.GetDescriptor(EditAndContinueErrorCode.ErrorReadingFile); errors = [Diagnostic.Create(descriptor, Location.None, [fileBeingRead, e.Message])]; @@ -491,7 +508,7 @@ public async ValueTask EmitSolutionUpdateAsync( var solutionUpdate = await EditSession.EmitSolutionUpdateAsync(solution, activeStatementSpanProvider, updateId, cancellationToken).ConfigureAwait(false); - solutionUpdate.Log(EditAndContinueService.Log, updateId); + solutionUpdate.Log(SessionLog, updateId); _lastModuleUpdatesLog = solutionUpdate.ModuleUpdates.Updates; if (solutionUpdate.ModuleUpdates.Status == ModuleUpdateStatus.Ready) @@ -689,7 +706,7 @@ public async ValueTask>> GetB var analyzer = newProject.Services.GetRequiredService(); - await foreach (var documentId in EditSession.GetChangedDocumentsAsync(oldProject, newProject, cancellationToken).ConfigureAwait(false)) + await foreach (var documentId in EditSession.GetChangedDocumentsAsync(SessionLog, oldProject, newProject, cancellationToken).ConfigureAwait(false)) { cancellationToken.ThrowIfCancellationRequested(); @@ -710,6 +727,7 @@ public async ValueTask>> GetB newDocument, newActiveStatementSpans: [], EditSession.Capabilities, + AnalysisLog, cancellationToken).ConfigureAwait(false); // Document content did not change or unable to determine active statement spans in a document with syntax errors: @@ -821,7 +839,7 @@ public async ValueTask> GetAdjustedActiveSta adjustedMappedSpans.AddRange(newDocumentActiveStatementSpans); // Update tracking spans to the latest known locations of the active statements contained in changed documents based on their analysis. - await foreach (var unmappedDocumentId in EditSession.GetChangedDocumentsAsync(oldProject, newProject, cancellationToken).ConfigureAwait(false)) + await foreach (var unmappedDocumentId in EditSession.GetChangedDocumentsAsync(SessionLog, oldProject, newProject, cancellationToken).ConfigureAwait(false)) { var newUnmappedDocument = await newSolution.GetRequiredDocumentAsync(unmappedDocumentId, includeSourceGenerated: true, cancellationToken).ConfigureAwait(false); diff --git a/src/Features/Core/Portable/EditAndContinue/DebuggingSessionId.cs b/src/Features/Core/Portable/EditAndContinue/DebuggingSessionId.cs index 50a5eca2ef628..5b876bb1a3f7e 100644 --- a/src/Features/Core/Portable/EditAndContinue/DebuggingSessionId.cs +++ b/src/Features/Core/Portable/EditAndContinue/DebuggingSessionId.cs @@ -13,4 +13,8 @@ public override string ToString() => Ordinal.ToString(); } -internal readonly record struct UpdateId(DebuggingSessionId SessionId, int Ordinal); +internal readonly record struct UpdateId(DebuggingSessionId SessionId, int Ordinal) +{ + public override string ToString() + => $"{SessionId}.{Ordinal}"; +} diff --git a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDocumentAnalysesCache.cs b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDocumentAnalysesCache.cs index d348ad91667d6..3f1731df2d80d 100644 --- a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDocumentAnalysesCache.cs +++ b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDocumentAnalysesCache.cs @@ -21,12 +21,13 @@ namespace Microsoft.CodeAnalysis.EditAndContinue; /// The work is triggered by an incremental analyzer on idle or explicitly when "continue" operation is executed. /// Contains analyses of the latest observed document versions. /// -internal sealed class EditAndContinueDocumentAnalysesCache(AsyncLazy baseActiveStatements, AsyncLazy capabilities) +internal sealed class EditAndContinueDocumentAnalysesCache(AsyncLazy baseActiveStatements, AsyncLazy capabilities, TraceLog log) { private readonly object _guard = new(); private readonly Dictionary results, Project baseProject, Document document, ImmutableArray activeStatementSpans)> _analyses = []; private readonly AsyncLazy _baseActiveStatements = baseActiveStatements; private readonly AsyncLazy _capabilities = capabilities; + private readonly TraceLog _log = log; public async ValueTask> GetDocumentAnalysesAsync( CommittedSolution oldSolution, @@ -187,7 +188,7 @@ static async (arg, cancellationToken) => try { var analyzer = arg.document.Project.Services.GetRequiredService(); - return await analyzer.AnalyzeDocumentAsync(arg.baseProject, arg.self._baseActiveStatements, arg.document, arg.activeStatementSpans, arg.self._capabilities, cancellationToken).ConfigureAwait(false); + return await analyzer.AnalyzeDocumentAsync(arg.baseProject, arg.self._baseActiveStatements, arg.document, arg.activeStatementSpans, arg.self._capabilities, arg.self._log, cancellationToken).ConfigureAwait(false); } catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken)) { diff --git a/src/Features/Core/Portable/EditAndContinue/EditAndContinueService.cs b/src/Features/Core/Portable/EditAndContinue/EditAndContinueService.cs index 7dbaac5cb635f..4974ec41aba52 100644 --- a/src/Features/Core/Portable/EditAndContinue/EditAndContinueService.cs +++ b/src/Features/Core/Portable/EditAndContinue/EditAndContinueService.cs @@ -45,10 +45,12 @@ private sealed class VoidSessionTracker : IEditAndContinueSessionTracker public ImmutableArray ApplyChangesDiagnostics => []; } - internal static readonly TraceLog Log; - internal static readonly TraceLog AnalysisLog; + private static readonly string? s_logDir = GetLogDirectory(); - private Func _compilationOutputsProvider; + internal readonly TraceLog Log; + internal readonly TraceLog AnalysisLog; + + private Func _compilationOutputsProvider = GetCompilationOutputs; /// /// List of active debugging sessions (small number of simoultaneously active sessions is expected). @@ -58,21 +60,16 @@ private sealed class VoidSessionTracker : IEditAndContinueSessionTracker [ImportingConstructor] [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public EditAndContinueService() - { - _compilationOutputsProvider = GetCompilationOutputs; - } - - static EditAndContinueService() + public EditAndContinueService( + [Import(AllowDefault = true)] IEditAndContinueLogReporter? logReporter) { - Log = new(2048, "EnC", "Trace.log"); - AnalysisLog = new(1024, "EnC", "Analysis.log"); + Log = new TraceLog("Session", logReporter); + AnalysisLog = new TraceLog("Analysis", logReporter); - var logDir = GetLogDirectory(); - if (logDir != null) + if (s_logDir != null) { - Log.SetLogDirectory(logDir); - AnalysisLog.SetLogDirectory(logDir); + Log.SetLogDirectory(s_logDir); + AnalysisLog.SetLogDirectory(s_logDir); } } @@ -97,7 +94,9 @@ static EditAndContinueService() public void SetFileLoggingDirectory(string? logDirectory) { - Log.SetLogDirectory(logDirectory ?? GetLogDirectory()); + logDirectory ??= GetLogDirectory(); + Log.SetLogDirectory(logDirectory); + AnalysisLog.SetLogDirectory(logDirectory); } private static CompilationOutputs GetCompilationOutputs(Project project) @@ -153,7 +152,7 @@ public async ValueTask StartDebuggingSessionAsync( ? solution.Projects.Select(project => (project, project.State.DocumentStates.States.Values)) : GetDocumentStatesGroupedByProject(solution, captureMatchingDocuments); - initialDocumentStates = await CommittedSolution.GetMatchingDocumentsAsync(documentsByProject, _compilationOutputsProvider, sourceTextProvider, cancellationToken).ConfigureAwait(false); + initialDocumentStates = await CommittedSolution.GetMatchingDocumentsAsync(Log, documentsByProject, _compilationOutputsProvider, sourceTextProvider, cancellationToken).ConfigureAwait(false); } else { @@ -164,14 +163,14 @@ public async ValueTask StartDebuggingSessionAsync( solution = solution.WithUpToDateSourceGeneratorDocuments(solution.ProjectIds); var sessionId = new DebuggingSessionId(Interlocked.Increment(ref s_debuggingSessionId)); - var session = new DebuggingSession(sessionId, solution, debuggerService, _compilationOutputsProvider, sourceTextProvider, initialDocumentStates, reportDiagnostics); + var session = new DebuggingSession(sessionId, solution, debuggerService, _compilationOutputsProvider, sourceTextProvider, initialDocumentStates, Log, AnalysisLog, reportDiagnostics); lock (_debuggingSessions) { _debuggingSessions.Add(session); } - Log.Write("Session #{0} started.", sessionId.Ordinal); + Log.Write($"Session #{sessionId} started."); return sessionId; } @@ -200,7 +199,7 @@ public void EndDebuggingSession(DebuggingSessionId sessionId) debuggingSession.EndSession(out var telemetryData); - Log.Write("Session #{0} ended.", debuggingSession.Id.Ordinal); + Log.Write($"Session #{debuggingSession.Id} ended."); } public void BreakStateOrCapabilitiesChanged(DebuggingSessionId sessionId, bool? inBreakState) diff --git a/src/Features/Core/Portable/EditAndContinue/EditSession.cs b/src/Features/Core/Portable/EditAndContinue/EditSession.cs index a366b17b46a5a..4e9ea34a5b0a8 100644 --- a/src/Features/Core/Portable/EditAndContinue/EditSession.cs +++ b/src/Features/Core/Portable/EditAndContinue/EditSession.cs @@ -108,9 +108,13 @@ internal EditSession( Capabilities = AsyncLazy.Create(static (self, cancellationToken) => self.GetCapabilitiesAsync(cancellationToken), arg: this); - Analyses = new EditAndContinueDocumentAnalysesCache(BaseActiveStatements, Capabilities); + + Analyses = new EditAndContinueDocumentAnalysesCache(BaseActiveStatements, Capabilities, debuggingSession.AnalysisLog); } + public TraceLog Log + => DebuggingSession.SessionLog; + /// /// The compiler has various scenarios that will cause it to synthesize things that might not be covered /// by existing rude edits, but we still need to ensure the runtime supports them before we proceed. @@ -423,7 +427,7 @@ internal static async ValueTask HasChangedOrAddedDocumentsAsync(Project ol return false; } - internal static async Task PopulateChangedAndAddedDocumentsAsync(Project oldProject, Project newProject, ArrayBuilder changedOrAddedDocuments, ArrayBuilder diagnostics, CancellationToken cancellationToken) + internal static async Task PopulateChangedAndAddedDocumentsAsync(TraceLog log, Project oldProject, Project newProject, ArrayBuilder changedOrAddedDocuments, ArrayBuilder diagnostics, CancellationToken cancellationToken) { changedOrAddedDocuments.Clear(); @@ -432,10 +436,10 @@ internal static async Task PopulateChangedAndAddedDocumentsAsync(Project oldProj return; } - var oldSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(oldProject, diagnostics, cancellationToken).ConfigureAwait(false); + var oldSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(log, oldProject, diagnostics, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); - var newSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(newProject, diagnostics, cancellationToken).ConfigureAwait(false); + var newSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(log, newProject, diagnostics, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); foreach (var documentId in newSourceGeneratedDocumentStates.GetChangedStateIds(oldSourceGeneratedDocumentStates, ignoreUnchangedContent: true)) @@ -461,7 +465,7 @@ internal static async Task PopulateChangedAndAddedDocumentsAsync(Project oldProj } } - private static async ValueTask> GetSourceGeneratedDocumentStatesAsync(Project project, ArrayBuilder? diagnostics, CancellationToken cancellationToken) + private static async ValueTask> GetSourceGeneratedDocumentStatesAsync(TraceLog log, Project project, ArrayBuilder? diagnostics, CancellationToken cancellationToken) { var generatorDiagnostics = await project.Solution.CompilationState.GetSourceGeneratorDiagnosticsAsync(project.State, cancellationToken).ConfigureAwait(false); @@ -472,7 +476,12 @@ private static async ValueTask> foreach (var generatorDiagnostic in generatorDiagnostics) { - EditAndContinueService.Log.Write("Source generator failed: {0}", generatorDiagnostic); + log.Write($"Source generator failed: {generatorDiagnostic}", generatorDiagnostic.Severity switch + { + DiagnosticSeverity.Warning => LogMessageSeverity.Warning, + DiagnosticSeverity.Error => LogMessageSeverity.Error, + _ => LogMessageSeverity.Info + }); } return await project.Solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, cancellationToken).ConfigureAwait(false); @@ -481,7 +490,7 @@ private static async ValueTask> /// /// Enumerates s of changed (not added or removed) s (not additional nor analyzer config). /// - internal static async IAsyncEnumerable GetChangedDocumentsAsync(Project oldProject, Project newProject, [EnumeratorCancellation] CancellationToken cancellationToken) + internal static async IAsyncEnumerable GetChangedDocumentsAsync(TraceLog log, Project oldProject, Project newProject, [EnumeratorCancellation] CancellationToken cancellationToken) { Debug.Assert(oldProject.Id == newProject.Id); @@ -511,10 +520,10 @@ internal static async IAsyncEnumerable GetChangedDocumentsAsync(Proj yield break; } - var oldSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(oldProject, diagnostics: null, cancellationToken).ConfigureAwait(false); + var oldSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(log, oldProject, diagnostics: null, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); - var newSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(newProject, diagnostics: null, cancellationToken).ConfigureAwait(false); + var newSourceGeneratedDocumentStates = await GetSourceGeneratedDocumentStatesAsync(log, newProject, diagnostics: null, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); foreach (var documentId in newSourceGeneratedDocumentStates.GetChangedStateIds(oldSourceGeneratedDocumentStates, ignoreUnchangedContent: true)) @@ -798,11 +807,9 @@ internal static void MergePartialEdits( public async ValueTask EmitSolutionUpdateAsync(Solution solution, ActiveStatementSpanProvider solutionActiveStatementSpanProvider, UpdateId updateId, CancellationToken cancellationToken) { - var log = EditAndContinueService.Log; - try { - log.Write("EmitSolutionUpdate {0}.{1}: '{2}'", updateId.SessionId.Ordinal, updateId.Ordinal, solution.FilePath); + Log.Write($"Found {updateId.SessionId} potentially changed document(s) in project {updateId.Ordinal} '{solution.FilePath}'"); using var _1 = ArrayBuilder.GetInstance(out var deltas); using var _2 = ArrayBuilder<(Guid ModuleId, ImmutableArray<(ManagedModuleMethodId Method, NonRemappableRegion Region)>)>.GetInstance(out var nonRemappableRegions); @@ -818,7 +825,7 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution var hasEmitErrors = false; foreach (var newProject in solution.Projects) { - if (!newProject.SupportsEditAndContinue(log)) + if (!newProject.SupportsEditAndContinue(Log)) { continue; } @@ -826,7 +833,7 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution var oldProject = oldSolution.GetProject(newProject.Id); if (oldProject == null) { - log.Write("EnC state of {0} '{1}' queried: project not loaded", newProject.Name, newProject.FilePath); + Log.Write($"EnC state of {newProject.Name} '{newProject.FilePath}' queried: project not loaded"); // TODO (https://github.com/dotnet/roslyn/issues/1204): // @@ -842,13 +849,13 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution continue; } - await PopulateChangedAndAddedDocumentsAsync(oldProject, newProject, changedOrAddedDocuments, diagnostics, cancellationToken).ConfigureAwait(false); + await PopulateChangedAndAddedDocumentsAsync(Log, oldProject, newProject, changedOrAddedDocuments, diagnostics, cancellationToken).ConfigureAwait(false); if (changedOrAddedDocuments.IsEmpty) { continue; } - log.Write("Found {0} potentially changed document(s) in project {1} '{2}'", changedOrAddedDocuments.Count, newProject.Name, newProject.FilePath); + Log.Write($"Found {changedOrAddedDocuments.Count} potentially changed document(s) in project {newProject.Name} '{newProject.FilePath}'"); var (mvid, mvidReadError) = await DebuggingSession.GetProjectModuleIdAsync(newProject, cancellationToken).ConfigureAwait(false); if (mvidReadError != null) @@ -865,7 +872,7 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution if (mvid == Guid.Empty) { - log.Write("Emitting update of {0} '{1}': project not built", newProject.Name, newProject.FilePath); + Log.Write($"Emitting update of {newProject.Name} '{newProject.FilePath}': project not built"); continue; } @@ -901,18 +908,18 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution // only remember the first syntax error we encounter: syntaxError ??= changedDocumentAnalysis.SyntaxError; - log.Write("Changed document '{0}' has syntax error: {1}", changedDocumentAnalysis.FilePath, changedDocumentAnalysis.SyntaxError); + Log.Write($"Changed document '{changedDocumentAnalysis.FilePath}' has syntax error: {changedDocumentAnalysis.SyntaxError}"); } else if (changedDocumentAnalysis.HasChanges) { - log.Write("Document changed, added, or deleted: '{0}'", changedDocumentAnalysis.FilePath); + Log.Write($"Document changed, added, or deleted: '{changedDocumentAnalysis.FilePath}'"); } Telemetry.LogAnalysisTime(changedDocumentAnalysis.ElapsedTime); } var projectSummary = GetProjectAnalysisSummary(changedDocumentAnalyses); - log.Write("Project summary for {0} '{1}': {2}", newProject.Name, newProject.FilePath, projectSummary); + Log.Write($"Project summary for {newProject.Name} '{newProject.FilePath}': {projectSummary}"); if (projectSummary == ProjectAnalysisSummary.NoChanges) { @@ -972,7 +979,7 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution Contract.ThrowIfTrue(projectBaselines.IsEmpty); - log.Write("Emitting update of '{0}' {1}", newProject.Name, newProject.FilePath); + Log.Write($"Emitting update of {newProject.Name} '{newProject.FilePath}': project not built"); var newCompilation = await newProject.GetCompilationAsync(cancellationToken).ConfigureAwait(false); @@ -1092,7 +1099,7 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution nonRemappableRegions.Add((mvid, moduleNonRemappableRegions)); newProjectBaselines.Add(new ProjectBaseline(mvid, projectBaseline.ProjectId, emitResult.Baseline, projectBaseline.Generation + 1)); - var fileLog = log.FileLog; + var fileLog = Log.FileLog; if (fileLog != null) { await LogDeltaFilesAsync(fileLog, delta, projectBaseline.Generation, oldProject, newProject, cancellationToken).ConfigureAwait(false); @@ -1103,7 +1110,7 @@ public async ValueTask EmitSolutionUpdateAsync(Solution solution async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cancellationToken) { - var fileLog = log.FileLog; + var fileLog = Log.FileLog; if (fileLog != null) { foreach (var changedDocumentAnalysis in changedDocumentAnalyses) @@ -1146,7 +1153,7 @@ async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cance bool LogException(Exception e) { - log.Write("Exception while emitting update: {0}", e.ToString()); + Log.Write($"Exception while emitting update: {e}", LogMessageSeverity.Error); return true; } } diff --git a/src/Features/Core/Portable/EditAndContinue/IEditAndContinueAnalyzer.cs b/src/Features/Core/Portable/EditAndContinue/IEditAndContinueAnalyzer.cs index 5e6c4c41282b4..c6da806aaa752 100644 --- a/src/Features/Core/Portable/EditAndContinue/IEditAndContinueAnalyzer.cs +++ b/src/Features/Core/Portable/EditAndContinue/IEditAndContinueAnalyzer.cs @@ -19,6 +19,7 @@ Task AnalyzeDocumentAsync( Document document, ImmutableArray newActiveStatementSpans, AsyncLazy lazyCapabilities, + TraceLog log, CancellationToken cancellationToken); ActiveStatementExceptionRegions GetExceptionRegions(SyntaxNode syntaxRoot, TextSpan unmappedActiveStatementSpan, bool isNonLeaf, CancellationToken cancellationToken); diff --git a/src/Features/Core/Portable/EditAndContinue/IEditAndContinueLogReporter.cs b/src/Features/Core/Portable/EditAndContinue/IEditAndContinueLogReporter.cs new file mode 100644 index 0000000000000..629cff4e10269 --- /dev/null +++ b/src/Features/Core/Portable/EditAndContinue/IEditAndContinueLogReporter.cs @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.CodeAnalysis.EditAndContinue; + +/// +/// Exported by the host to provide additional logging for EnC operations. +/// +internal interface IEditAndContinueLogReporter +{ + void Report(string message, LogMessageSeverity severity); +} diff --git a/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs b/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs index 9f39ed9eb3223..3b6caa83edbb3 100644 --- a/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs +++ b/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Immutable; +using System.Linq; using Microsoft.CodeAnalysis.Contracts.EditAndContinue; namespace Microsoft.CodeAnalysis.EditAndContinue; @@ -30,22 +31,22 @@ public static SolutionUpdate Blocked( bool hasEmitErrors) => new( new(syntaxError != null || hasEmitErrors ? ModuleUpdateStatus.Blocked : ModuleUpdateStatus.RestartRequired, []), - [], - [], + nonRemappableRegions: [], + projectBaselines: [], diagnostics, documentsWithRudeEdits, syntaxError); internal void Log(TraceLog log, UpdateId updateId) { - log.Write("Solution update {0}.{1} status: {2}", updateId.SessionId.Ordinal, updateId.Ordinal, ModuleUpdates.Status); + log.Write($"Solution update {updateId} status: {ModuleUpdates.Status}"); foreach (var moduleUpdate in ModuleUpdates.Updates) { - log.Write("Module update: capabilities=[{0}], types=[{1}], methods=[{2}]", - moduleUpdate.RequiredCapabilities, - moduleUpdate.UpdatedTypes, - moduleUpdate.UpdatedMethods); + log.Write("Module update: " + + $"capabilities=[{string.Join(",", moduleUpdate.RequiredCapabilities)}], " + + $"types=[{string.Join(",", moduleUpdate.UpdatedTypes.Select(token => token.ToString("X8")))}], " + + $"methods=[{string.Join(",", moduleUpdate.UpdatedMethods.Select(token => token.ToString("X8")))}]"); } foreach (var projectDiagnostics in Diagnostics) @@ -54,7 +55,7 @@ internal void Log(TraceLog log, UpdateId updateId) { if (diagnostic.Severity == DiagnosticSeverity.Error) { - log.Write("Project {0} update error: {1}", projectDiagnostics.ProjectId, diagnostic); + log.Write($"Project {projectDiagnostics.ProjectId.DebugName} update error: {diagnostic}", LogMessageSeverity.Error); } } } @@ -63,7 +64,7 @@ internal void Log(TraceLog log, UpdateId updateId) { foreach (var rudeEdit in documentWithRudeEdits.Diagnostics) { - log.Write("Document {0} rude edit: {1} {2}", documentWithRudeEdits.DocumentId, rudeEdit.Kind, rudeEdit.SyntaxKind); + log.Write($"Document {documentWithRudeEdits.DocumentId.DebugName} rude edit: {rudeEdit.Kind} {rudeEdit.SyntaxKind}", LogMessageSeverity.Error); } } } diff --git a/src/Features/Core/Portable/EditAndContinue/TraceLog.cs b/src/Features/Core/Portable/EditAndContinue/TraceLog.cs index 49772254899dd..410ce06ea5912 100644 --- a/src/Features/Core/Portable/EditAndContinue/TraceLog.cs +++ b/src/Features/Core/Portable/EditAndContinue/TraceLog.cs @@ -6,8 +6,6 @@ using System.Collections.Immutable; using System.Diagnostics; using System.IO; -using System.Linq; -using System.Runtime.CompilerServices; using System.Text; using System.Threading; using System.Threading.Tasks; @@ -15,111 +13,36 @@ namespace Microsoft.CodeAnalysis.EditAndContinue; +internal enum LogMessageSeverity +{ + Info, + Warning, + Error +} + /// -/// Fixed size rolling tracing log. +/// Implements EnC logging. +/// +/// Writes log messages to: +/// - fixed size rolling tracing log captured in a memory dump, +/// - a file log, if a log directory is provided, +/// - log service, if avaiable. /// -/// -/// Recent entries are captured in a memory dump. -/// If DEBUG is defined, all entries written to or -/// are print to output. -/// -internal sealed class TraceLog(int logSize, string id, string fileName) +internal sealed class TraceLog(string name, IEditAndContinueLogReporter? logService = null, int logSize = 2048) { - internal readonly struct Arg - { - // To display enums in Expression Evaluator we need to remember the type of the enum. - // The debugger currently does not support evaluating expressions that involve Type instances nor lambdas, - // so we need to manually special case the types of enums we care about displaying. - - private enum EnumType - { - ProjectAnalysisSummary, - RudeEditKind, - ModuleUpdateStatus, - EditAndContinueCapabilities, - } - - private static readonly StrongBox s_ProjectAnalysisSummary = new(EnumType.ProjectAnalysisSummary); - private static readonly StrongBox s_RudeEditKind = new(EnumType.RudeEditKind); - private static readonly StrongBox s_ModuleUpdateStatus = new(EnumType.ModuleUpdateStatus); - private static readonly StrongBox s_EditAndContinueCapabilities = new(EnumType.EditAndContinueCapabilities); - - public readonly object? Object; - public readonly int Int32; - public readonly ImmutableArray Tokens; - - public Arg(object? value) - { - Int32 = -1; - Object = value ?? ""; - Tokens = default; - } - - public Arg(ImmutableArray tokens) - { - Int32 = -1; - Object = null; - Tokens = tokens; - } - - private Arg(int value, StrongBox enumKind) - { - Int32 = value; - Object = enumKind; - Tokens = default; - } - - public object? GetDebuggerDisplay() - => (!Tokens.IsDefault) ? string.Join(",", Tokens.Select(token => token.ToString("X8"))) : - (Object is ImmutableArray array) ? string.Join(",", array) : - (Object is null) ? Int32 : - (Object is StrongBox { Value: var enumType }) ? enumType switch - { - EnumType.ProjectAnalysisSummary => (ProjectAnalysisSummary)Int32, - EnumType.RudeEditKind => (RudeEditKind)Int32, - EnumType.ModuleUpdateStatus => (ModuleUpdateStatus)Int32, - EnumType.EditAndContinueCapabilities => (EditAndContinueCapabilities)Int32, - _ => throw ExceptionUtilities.UnexpectedValue(enumType) - } : - Object; - - public static implicit operator Arg(string? value) => new(value); - public static implicit operator Arg(int value) => new(value); - public static implicit operator Arg(bool value) => new(value ? "true" : "false"); - public static implicit operator Arg(ProjectId value) => new(value.DebugName); - public static implicit operator Arg(DocumentId value) => new(value.DebugName); - public static implicit operator Arg(Diagnostic value) => new(value.ToString()); - public static implicit operator Arg(ProjectAnalysisSummary value) => new((int)value, s_ProjectAnalysisSummary); - public static implicit operator Arg(RudeEditKind value) => new((int)value, s_RudeEditKind); - public static implicit operator Arg(ModuleUpdateStatus value) => new((int)value, s_ModuleUpdateStatus); - public static implicit operator Arg(EditAndContinueCapabilities value) => new((int)value, s_EditAndContinueCapabilities); - public static implicit operator Arg(ImmutableArray tokens) => new(tokens); - public static implicit operator Arg(ImmutableArray items) => new(items); - } - - [DebuggerDisplay("{GetDebuggerDisplay(),nq}")] - internal readonly struct Entry(string format, Arg[]? args) - { - public readonly string MessageFormat = format; - public readonly Arg[]? Args = args; - - internal string GetDebuggerDisplay() - => (MessageFormat == null) ? "" : string.Format(MessageFormat, Args?.Select(a => a.GetDebuggerDisplay()).ToArray() ?? []); - } - internal sealed class FileLogger(string logDirectory, TraceLog traceLog) { private readonly string _logDirectory = logDirectory; private readonly TraceLog _traceLog = traceLog; - public void Append(Entry entry) + public void Append(string entry) { string? path = null; try { - path = Path.Combine(_logDirectory, _traceLog._fileName); - File.AppendAllLines(path, [entry.GetDebuggerDisplay()]); + path = Path.Combine(_logDirectory, _traceLog._name + ".log"); + File.AppendAllLines(path, [entry]); } catch (Exception e) { @@ -214,9 +137,8 @@ public async ValueTask WriteDocumentChangeAsync(Document? oldDocument, Document? } } - private readonly Entry[] _log = new Entry[logSize]; - private readonly string _id = id; - private readonly string _fileName = fileName; + private readonly string[] _log = new string[logSize]; + private readonly string _name = name; private int _currentLine; public FileLogger? FileLog { get; private set; } @@ -226,37 +148,20 @@ public void SetLogDirectory(string? logDirectory) FileLog = (logDirectory != null) ? new FileLogger(logDirectory, this) : null; } - private void AppendInMemory(Entry entry) + private void AppendInMemory(string entry) { var index = Interlocked.Increment(ref _currentLine); _log[(index - 1) % _log.Length] = entry; } private void AppendFileLoggingErrorInMemory(string? path, Exception e) - => AppendInMemory(new Entry("Error writing log file '{0}': {1}", [new Arg(path), new Arg(e.Message)])); + => AppendInMemory($"Error writing log file '{path}': {e.Message}"); - private void Append(Entry entry) + public void Write(string message, LogMessageSeverity severity = LogMessageSeverity.Info) { - AppendInMemory(entry); - FileLog?.Append(entry); - } - - public void Write(string str) - => Write(str, args: null); - - public void Write(string format, params Arg[]? args) - => Append(new Entry(format, args)); - - [Conditional("DEBUG")] - public void DebugWrite(string str) - => DebugWrite(str, args: null); - - [Conditional("DEBUG")] - public void DebugWrite(string format, params Arg[]? args) - { - var entry = new Entry(format, args); - Append(entry); - Debug.WriteLine(entry.ToString(), _id); + AppendInMemory(message); + FileLog?.Append(message); + logService?.Report(message, severity); } internal TestAccessor GetTestAccessor() @@ -264,8 +169,7 @@ internal TestAccessor GetTestAccessor() internal readonly struct TestAccessor(TraceLog traceLog) { - private readonly TraceLog _traceLog = traceLog; - - internal Entry[] Entries => _traceLog._log; + internal string[] Entries => traceLog._log; } } + diff --git a/src/Features/Core/Portable/EditAndContinue/Utilities/Extensions.cs b/src/Features/Core/Portable/EditAndContinue/Utilities/Extensions.cs index 09e1958cf7f5f..d12eb72226d49 100644 --- a/src/Features/Core/Portable/EditAndContinue/Utilities/Extensions.cs +++ b/src/Features/Core/Portable/EditAndContinue/Utilities/Extensions.cs @@ -44,19 +44,19 @@ public static bool SupportsEditAndContinue(this Project project, TraceLog? log = { if (project.FilePath == null) { - log?.Write("Project '{0}' (id '{1}') doesn't support EnC: no file path", project.Name, project.Id); + log?.Write($"Project '{project.Name}' ('{project.Id.DebugName}') doesn't support EnC: no file path"); return false; } if (project.Services.GetService() == null) { - log?.Write("Project '{0}' doesn't support EnC: no EnC service", project.FilePath); + log?.Write($"Project '{project.FilePath}' doesn't support EnC: no EnC service"); return false; } if (!project.CompilationOutputInfo.HasEffectiveGeneratedFilesOutputDirectory) { - log?.Write("Project '{0}' doesn't support EnC: no generated files output directory", project.FilePath); + log?.Write($"Project '{project.FilePath}' doesn't support EnC: no generated files output directory"); return false; } diff --git a/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs b/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs index 89d5cb4e66699..f61982ada6dcc 100644 --- a/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs +++ b/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs @@ -1605,6 +1605,7 @@ public enum DocumentKind public async Task HasChanges_Documents(DocumentKind documentKind) { using var _ = CreateWorkspace(out var solution, out var service); + var log = new TraceLog("Test"); var pathX = Path.Combine(TempRoot.Root, "X.cs"); var pathA = Path.Combine(TempRoot.Root, "A.cs"); @@ -1677,10 +1678,10 @@ public async Task HasChanges_Documents(DocumentKind documentKind) Assert.Equal(0, generatorExecutionCount); AssertEx.Equal([generatedDocumentId], - await EditSession.GetChangedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); + await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); var diagnostics = new ArrayBuilder(); - await EditSession.PopulateChangedAndAddedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); + await EditSession.PopulateChangedAndAddedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); Assert.Empty(diagnostics); AssertEx.Equal(documentKind == DocumentKind.Source ? [documentId, generatedDocumentId] : [generatedDocumentId], changedOrAddedDocuments.Select(d => d.Id)); @@ -1707,9 +1708,9 @@ public async Task HasChanges_Documents(DocumentKind documentKind) // source generator infrastructure compares content and reuses state if it matches (SourceGeneratedDocumentState.WithUpdatedGeneratedContent): AssertEx.Equal(documentKind == DocumentKind.Source ? new[] { documentId } : [], - await EditSession.GetChangedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); + await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); - await EditSession.PopulateChangedAndAddedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); + await EditSession.PopulateChangedAndAddedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); Assert.Empty(diagnostics); Assert.Empty(changedOrAddedDocuments); @@ -1732,9 +1733,9 @@ public async Task HasChanges_Documents(DocumentKind documentKind) Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None)); AssertEx.Equal(documentKind == DocumentKind.Source ? [documentId, generatedDocumentId] : [generatedDocumentId], - await EditSession.GetChangedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); + await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); - await EditSession.PopulateChangedAndAddedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); + await EditSession.PopulateChangedAndAddedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); Assert.Empty(diagnostics); AssertEx.Equal(documentKind == DocumentKind.Source ? [documentId, generatedDocumentId] : [generatedDocumentId], changedOrAddedDocuments.Select(d => d.Id)); @@ -1759,9 +1760,9 @@ public async Task HasChanges_Documents(DocumentKind documentKind) Assert.Equal(0, generatorExecutionCount); AssertEx.Equal([generatedDocumentId], - await EditSession.GetChangedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); + await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); - await EditSession.PopulateChangedAndAddedDocumentsAsync(oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); + await EditSession.PopulateChangedAndAddedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), changedOrAddedDocuments, diagnostics, CancellationToken.None); Assert.Empty(diagnostics); AssertEx.Equal([generatedDocumentId], changedOrAddedDocuments.Select(d => d.Id)); @@ -1773,6 +1774,8 @@ public async Task HasChanges_SourceGeneratorFailure() { using var _ = CreateWorkspace(out var solution, out var service); + var log = new TraceLog("Test"); + var pathA = Path.Combine(TempRoot.Root, "A.txt"); var generatorExecutionCount = 0; @@ -1829,10 +1832,10 @@ public async Task HasChanges_SourceGeneratorFailure() Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); // No changed source documents since the generator failed: - AssertEx.Empty(await EditSession.GetChangedDocumentsAsync(oldProject, project, CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); + AssertEx.Empty(await EditSession.GetChangedDocumentsAsync(log, oldProject, project, CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); var diagnostics = new ArrayBuilder(); - await EditSession.PopulateChangedAndAddedDocumentsAsync(oldProject, project, changedOrAddedDocuments, diagnostics, CancellationToken.None); + await EditSession.PopulateChangedAndAddedDocumentsAsync(log, oldProject, project, changedOrAddedDocuments, diagnostics, CancellationToken.None); Assert.Contains("System.InvalidOperationException: Source generator failed", diagnostics.Single().Diagnostics.Single().GetMessage()); AssertEx.Empty(changedOrAddedDocuments); diff --git a/src/Features/Test/EditAndContinue/EditSessionActiveStatementsTests.cs b/src/Features/Test/EditAndContinue/EditSessionActiveStatementsTests.cs index a34b189667323..414b61dff1e7f 100644 --- a/src/Features/Test/EditAndContinue/EditSessionActiveStatementsTests.cs +++ b/src/Features/Test/EditAndContinue/EditSessionActiveStatementsTests.cs @@ -43,6 +43,8 @@ private static EditSession CreateEditSession( var mockCompilationOutputsProvider = new Func(_ => new MockCompilationOutputs(Guid.NewGuid())); + var log = new TraceLog("Test"); + var debuggingSession = new DebuggingSession( new DebuggingSessionId(1), solution, @@ -50,6 +52,8 @@ private static EditSession CreateEditSession( mockCompilationOutputsProvider, NullPdbMatchingSourceTextProvider.Instance, initialDocumentStates: [], + log, + log, reportDiagnostics: true); if (initialState != CommittedSolution.DocumentState.None) diff --git a/src/Features/Test/EditAndContinue/TraceLogTests.cs b/src/Features/Test/EditAndContinue/TraceLogTests.cs deleted file mode 100644 index 72f344f4bc8c0..0000000000000 --- a/src/Features/Test/EditAndContinue/TraceLogTests.cs +++ /dev/null @@ -1,39 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -using System; -using System.Linq; -using Roslyn.Test.Utilities; -using Xunit; - -namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests -{ - public class TraceLogTests - { - [Fact] - public void Write() - { - var log = new TraceLog(5, "log", "File.log"); - - var projectId = ProjectId.CreateFromSerialized(Guid.Parse("5E40F37C-5AB3-495E-A3F2-4A244D177674"), debugName: "MyProject"); - var diagnostic = Diagnostic.Create(EditAndContinueDiagnosticDescriptors.GetDescriptor(EditAndContinueErrorCode.ErrorReadingFile), Location.None, "file", "error"); - - log.Write("a"); - log.Write("b {0} {1} 0x{2:X8}", 1, "x", 255); - log.Write("c"); - log.Write("d str={0} projectId={1} summary={2} diagnostic=`{3}`", (string?)null, projectId, ProjectAnalysisSummary.RudeEdits, diagnostic); - log.Write("e"); - log.Write("f"); - - AssertEx.Equal( - [ - "f", - "b 1 x 0x000000FF", - "c", - $"d str= projectId=MyProject summary=RudeEdits diagnostic=`{diagnostic}`", - "e" - ], log.GetTestAccessor().Entries.Select(e => e.GetDebuggerDisplay())); - } - } -} diff --git a/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs b/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs index 3cb4688c41dc8..b55b5cdee56a6 100644 --- a/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs +++ b/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs @@ -18,6 +18,8 @@ using Roslyn.Utilities; using Xunit; using static Microsoft.CodeAnalysis.EditAndContinue.AbstractEditAndContinueAnalyzer; +using Microsoft.CodeAnalysis.Host.Mef; +using Microsoft.CodeAnalysis.Host; namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests { @@ -44,7 +46,12 @@ internal abstract class EditAndContinueTestVerifier EditAndContinueCapabilities.GenericUpdateMethod | EditAndContinueCapabilities.GenericAddFieldToExistingType; - public abstract AbstractEditAndContinueAnalyzer Analyzer { get; } + public AbstractEditAndContinueAnalyzer Analyzer { get; } + + protected EditAndContinueTestVerifier(Action? faultInjector) + { + Analyzer = CreateAnalyzer(faultInjector, LanguageName); + } public abstract ImmutableArray GetDeclarators(ISymbol method); public abstract string LanguageName { get; } @@ -52,6 +59,19 @@ internal abstract class EditAndContinueTestVerifier public abstract TreeComparer TopSyntaxComparer { get; } public abstract string? TryGetResource(string keyword); + internal static AbstractEditAndContinueAnalyzer CreateAnalyzer(Action? faultInjector, string languageName) + { + var exportProvider = FeaturesTestCompositions.Features.ExportProviderFactory.CreateExportProvider(); + + var analyzer = (AbstractEditAndContinueAnalyzer)exportProvider + .GetExports() + .Single(e => e.Metadata.Language == languageName && e.Metadata.ServiceType == typeof(IEditAndContinueAnalyzer).AssemblyQualifiedName) + .Value; + + analyzer.GetTestAccessor().FaultInjector = faultInjector; + return analyzer; + } + private void VerifyDocumentActiveStatementsAndExceptionRegions( ActiveStatementsDescription description, SyntaxTree oldTree, @@ -134,6 +154,7 @@ internal void VerifySemantics( var lazyCapabilities = AsyncLazy.Create(requiredCapabilities); var actualRequiredCapabilities = EditAndContinueCapabilities.None; var hasValidChanges = false; + var log = new TraceLog("Test"); for (var documentIndex = 0; documentIndex < documentCount; documentIndex++) { @@ -159,7 +180,7 @@ internal void VerifySemantics( Contract.ThrowIfNull(newModel); var lazyOldActiveStatementMap = AsyncLazy.Create(expectedResult.ActiveStatements.OldStatementsMap); - var result = Analyzer.AnalyzeDocumentAsync(oldProject, lazyOldActiveStatementMap, newDocument, newActiveStatementSpans, lazyCapabilities, CancellationToken.None).Result; + var result = Analyzer.AnalyzeDocumentAsync(oldProject, lazyOldActiveStatementMap, newDocument, newActiveStatementSpans, lazyCapabilities, log, CancellationToken.None).Result; var oldText = oldDocument.GetTextSynchronously(default); var newText = newDocument.GetTextSynchronously(default); diff --git a/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb b/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb index 5b72758a44be3..9dc1d8c1099d7 100644 --- a/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb +++ b/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb @@ -16,26 +16,13 @@ Imports Microsoft.CodeAnalysis.Text Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue + Friend NotInheritable Class VisualBasicEditAndContinueAnalyzer Inherits AbstractEditAndContinueAnalyzer - - Private NotInheritable Class Factory - Implements ILanguageServiceFactory - - - - Public Sub New() - End Sub - - Public Function CreateLanguageService(languageServices As HostLanguageServices) As ILanguageService Implements ILanguageServiceFactory.CreateLanguageService - Return New VisualBasicEditAndContinueAnalyzer(testFaultInjector:=Nothing) - End Function - End Class - - ' Public for testing purposes - Public Sub New(Optional testFaultInjector As Action(Of SyntaxNode) = Nothing) - MyBase.New(testFaultInjector) + + + Public Sub New() End Sub #Region "Syntax Analysis" diff --git a/src/Features/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb b/src/Features/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb index dcdf8673f37fe..25da7ef68dae2 100644 --- a/src/Features/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb +++ b/src/Features/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb @@ -28,11 +28,6 @@ Namespace System.Runtime.CompilerServices End Class End Namespace " - - Friend Shared Function CreateAnalyzer() As VisualBasicEditAndContinueAnalyzer - Return New VisualBasicEditAndContinueAnalyzer() - End Function - Public Enum MethodKind Regular Async @@ -249,7 +244,8 @@ End Namespace src2 As String, Optional kind As MethodKind = MethodKind.Regular) As IEnumerable(Of KeyValuePair(Of SyntaxNode, SyntaxNode)) Dim methodMatch = GetMethodMatch(src1, src2, kind) - Return EditAndContinueTestVerifier.GetMethodMatches(CreateAnalyzer(), methodMatch) + Dim analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector:=Nothing, LanguageNames.VisualBasic) + Return EditAndContinueTestVerifier.GetMethodMatches(analyzer, methodMatch) End Function Public Shared Function ToMatchingPairs(match As Match(Of SyntaxNode)) As MatchingPairs diff --git a/src/Features/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestVerifier.vb b/src/Features/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestVerifier.vb index 2390a592d9ac0..a414ba2176483 100644 --- a/src/Features/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestVerifier.vb +++ b/src/Features/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestVerifier.vb @@ -3,30 +3,21 @@ ' See the LICENSE file in the project root for more information. Imports System.Collections.Immutable -Imports Microsoft.CodeAnalysis.VisualBasic.EditAndContinue -Imports Microsoft.CodeAnalysis.VisualBasic.Symbols -Imports Microsoft.CodeAnalysis.EditAndContinue -Imports Microsoft.CodeAnalysis.EditAndContinue.UnitTests Imports Microsoft.CodeAnalysis.Differencing +Imports Microsoft.CodeAnalysis.EditAndContinue.UnitTests +Imports Microsoft.CodeAnalysis.VisualBasic.EditAndContinue Imports Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests +Imports Microsoft.CodeAnalysis.VisualBasic.Symbols Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EditAndContinue Friend NotInheritable Class VisualBasicEditAndContinueTestVerifier Inherits EditAndContinueTestVerifier - Private ReadOnly _analyzer As VisualBasicEditAndContinueAnalyzer - - Public Sub New(Optional faultInjector As Action(Of SyntaxNode) = Nothing) - _analyzer = New VisualBasicEditAndContinueAnalyzer(faultInjector) + Public Sub New() + MyBase.New(faultInjector:=Nothing) End Sub - Public Overrides ReadOnly Property Analyzer As AbstractEditAndContinueAnalyzer - Get - Return _analyzer - End Get - End Property - Public Overrides ReadOnly Property LanguageName As String Get Return LanguageNames.VisualBasic diff --git a/src/Features/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb b/src/Features/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb index 93213d9de10e3..8be82f9cf0d54 100644 --- a/src/Features/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb +++ b/src/Features/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb @@ -120,10 +120,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests End Sub Private Shared Async Function AnalyzeDocumentAsync(oldProject As Project, newDocument As Document, Optional activeStatementMap As ActiveStatementsMap = Nothing) As Task(Of DocumentAnalysisResults) - Dim analyzer = New VisualBasicEditAndContinueAnalyzer() + Dim analyzer = oldProject.Services.GetRequiredService(Of IEditAndContinueAnalyzer) Dim baseActiveStatements = AsyncLazy.Create(If(activeStatementMap, ActiveStatementsMap.Empty)) Dim capabilities = AsyncLazy.Create(EditAndContinueTestVerifier.Net5RuntimeCapabilities) - Return Await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, ImmutableArray(Of ActiveStatementLineSpan).Empty, capabilities, CancellationToken.None) + Dim log = New TraceLog("Test") + Return Await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, ImmutableArray(Of ActiveStatementLineSpan).Empty, capabilities, log, CancellationToken.None) End Function #End Region diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs index 83afec59d18ea..2aec192ec8b6d 100644 --- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs +++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs @@ -9,7 +9,6 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; -using ICSharpCode.Decompiler.Solution; using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.ErrorReporting; using Microsoft.CodeAnalysis.Host; diff --git a/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj index 10b5b49c28122..91da959adde14 100644 --- a/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj +++ b/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj @@ -23,6 +23,7 @@ + diff --git a/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/EditAndContinueLogReporter.cs b/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/EditAndContinueLogReporter.cs new file mode 100644 index 0000000000000..d00166c5ccccf --- /dev/null +++ b/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/EditAndContinueLogReporter.cs @@ -0,0 +1,64 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +#pragma warning disable CS0436 // Type conflicts with imported type (workaround for https://github.com/dotnet/roslyn/issues/76674) + +using System; +using System.Composition; +using System.Threading; +using Microsoft.CodeAnalysis.BrokeredServices; +using Microsoft.CodeAnalysis.Host.Mef; +using Microsoft.CodeAnalysis.Shared.TestHooks; +using Microsoft.VisualStudio.Debugger.Contracts.HotReload; +using Roslyn.Utilities; + +namespace Microsoft.CodeAnalysis.EditAndContinue; + +[Shared] +[Export(typeof(IEditAndContinueLogReporter))] +internal sealed class EditAndContinueLogReporter : IEditAndContinueLogReporter +{ + private readonly AsyncBatchingWorkQueue _queue; + + [ImportingConstructor] + [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] + public EditAndContinueLogReporter( + IServiceBrokerProvider serviceBrokerProvider, + IAsynchronousOperationListenerProvider listenerProvider) + { + var logger = new HotReloadLoggerProxy(serviceBrokerProvider.ServiceBroker); + + _queue = new AsyncBatchingWorkQueue( + delay: TimeSpan.Zero, + async (messages, cancellationToken) => + { + try + { + foreach (var message in messages) + { + await logger.LogAsync(message, cancellationToken).ConfigureAwait(false); + } + } + catch + { + // Ignore. When running OOP the connection to the debugger log service might have been terminated. + } + }, + listenerProvider.GetListener(FeatureAttribute.EditAndContinue), + CancellationToken.None); + } + + public void Report(string message, LogMessageSeverity severity) + { + var (verbosity, errorLevel) = severity switch + { + LogMessageSeverity.Info => (HotReloadVerbosity.Diagnostic, HotReloadDiagnosticErrorLevel.Info), + LogMessageSeverity.Warning => (HotReloadVerbosity.Minimal, HotReloadDiagnosticErrorLevel.Warning), + LogMessageSeverity.Error => (HotReloadVerbosity.Minimal, HotReloadDiagnosticErrorLevel.Error), + _ => throw ExceptionUtilities.UnexpectedValue(severity), + }; + + _queue.AddWork(new HotReloadLogMessage(verbosity, message, errorLevel: errorLevel)); + } +} diff --git a/src/EditorFeatures/Core/EditAndContinue/Contracts/HotReloadLoggerProxy.cs b/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/HotReloadLoggerProxy.cs similarity index 100% rename from src/EditorFeatures/Core/EditAndContinue/Contracts/HotReloadLoggerProxy.cs rename to src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/HotReloadLoggerProxy.cs From 7c1d17a8f4c6d6b21fbdd7655e4e4ac294c0538a Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 09:26:09 -0800 Subject: [PATCH 34/76] Record completion of "Simple lambda parameters with modifiers" feature (#76884) --- docs/Language Feature Status.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md index d35426981d164..7061a36461d67 100644 --- a/docs/Language Feature Status.md +++ b/docs/Language Feature Status.md @@ -12,7 +12,6 @@ efforts behind them. | ------- | ------ | ----- | --------- | -------- | --------- | --------- | | [Partial Events and Constructors](https://github.com/dotnet/csharplang/issues/9058) | [features/PartialEventsCtors](https://github.com/dotnet/roslyn/tree/features/PartialEventsCtors) | [In Progress](https://github.com/dotnet/roslyn/issues/76859) | [jjonescz](https://github.com/jjonescz) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | | | | Runtime Async | [features/runtime-async](https://github.com/dotnet/roslyn/tree/features/runtime-async) | [In Progress](https://github.com/dotnet/roslyn/issues/75960) | [333fred](https://github.com/333fred) | [jcouv](https://github.com/jcouv), [RikkiGibson](https://github.com/RikkiGibson) | | | -| [Simple lambda parameters with modifiers](https://github.com/dotnet/csharplang/blob/main/proposals/simple-lambda-parameters-with-modifiers.md) | [PR](https://github.com/dotnet/roslyn/pull/75400) | [In Progress](https://github.com/dotnet/roslyn/issues/76298) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jjonescz](https://github.com/jjonescz), [cston](https://github.com/cston) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | | [Null-conditional assignment](https://github.com/dotnet/csharplang/issues/6045) | [null-conditional-assignment](https://github.com/dotnet/roslyn/tree/features/null-conditional-assignment) | [In Progress](https://github.com/dotnet/roslyn/issues/75554) | [RikkiGibson](https://github.com/RikkiGibson) | [cston](https://github.com/cston), [jjonescz](https://github.com/jjonescz) | TBD | [RikkiGibson](https://github.com/RikkiGibson) | | [Extensions](https://github.com/dotnet/csharplang/issues/8697) | [extensions](https://github.com/dotnet/roslyn/tree/features/extensions) | [In Progress](https://github.com/dotnet/roslyn/issues/76130) | [jcouv](https://github.com/jcouv), [AlekseyTs](https://github.com/AlekseyTs) | [jjonescz](https://github.com/jjonescz), TBD | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [MadsTorgersen](https://github.com/MadsTorgersen) | | [Dictionary expressions](https://github.com/dotnet/csharplang/issues/8659) | [dictionary-expressions](https://github.com/dotnet/roslyn/tree/features/dictionary-expressions) | [In Progress](https://github.com/dotnet/roslyn/issues/76310) | [cston](https://github.com/cston), [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [333fred](https://github.com/333fred), [jcouv](https://github.com/jcouv) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | @@ -20,6 +19,7 @@ efforts behind them. | [First-class Span Types](https://github.com/dotnet/csharplang/issues/7905) | [FirstClassSpan](https://github.com/dotnet/roslyn/tree/features/FirstClassSpan) | [Merged into 17.13p1](https://github.com/dotnet/roslyn/issues/73445) | [jjonescz](https://github.com/jjonescz) | [cston](https://github.com/cston), [333fred](https://github.com/333fred) | | [333fred](https://github.com/333fred), [stephentoub](https://github.com/stephentoub) | | [Unbound generic types in `nameof`](https://github.com/dotnet/csharplang/issues/8480) | [PR](https://github.com/dotnet/roslyn/pull/75368) | [Merged into 17.13p2](https://github.com/dotnet/roslyn/pull/75368) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv), [AlekseyTs](https://github.com/AlekseyTs) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | | [String literals in data section as UTF8](https://github.com/dotnet/roslyn/blob/main/docs/features/string-literals-data-section.md) | [PR](https://github.com/dotnet/roslyn/pull/76036) | [Merged into 17.14p1](https://github.com/dotnet/roslyn/issues/76234) | [jjonescz](https://github.com/jjonescz) | [AlekseyTs](https://github.com/AlekseyTs), [cston](https://github.com/cston) | N/A | N/A | +| [Simple lambda parameters with modifiers](https://github.com/dotnet/csharplang/blob/main/proposals/simple-lambda-parameters-with-modifiers.md) | [PR](https://github.com/dotnet/roslyn/pull/75400) | [Merged into 17.14p1](https://github.com/dotnet/roslyn/pull/75400) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jjonescz](https://github.com/jjonescz), [cston](https://github.com/cston) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | # Working Set VB From cd505c928967ed260b9ceae3916527d44c2e6402 Mon Sep 17 00:00:00 2001 From: Theodore Tsirpanis Date: Thu, 23 Jan 2025 20:32:42 +0200 Subject: [PATCH 35/76] Remove workaround for old version of SRM. (#76826) The issue mentioned in the comment has been fixed since almost nine years ago. --- .../Core/Portable/MetadataReference/ModuleMetadata.cs | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs b/src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs index 58d64292d8f73..ab9a5f805e3dd 100644 --- a/src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs +++ b/src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs @@ -240,13 +240,6 @@ public static ModuleMetadata CreateFromStream(Stream peStream, PEStreamOptions o } } - // Workaround of issue https://github.com/dotnet/corefx/issues/1815: - if (peStream.Length == 0 && (options & PEStreamOptions.PrefetchEntireImage) != 0 && (options & PEStreamOptions.PrefetchMetadata) != 0) - { - // throws BadImageFormatException: - new PEHeaders(peStream); - } - // ownership of the stream is passed on PEReader: return new ModuleMetadata(new PEReader(peStream, options), onDispose: null); } From 6102e51cf979d18dffef804f876922d11776cae3 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 12:28:08 -0800 Subject: [PATCH 36/76] Do not offer the containing type when offering completion in teh base-list --- .../CSharpCompletionCommandHandlerTests.vb | 67 +++++++ .../CSharpRecommendationServiceRunner.cs | 19 +- .../ContextQuery/CSharpSyntaxContext.cs | 43 ++--- .../ContextQuery/SyntaxTreeExtensions.cs | 13 ++ .../Extensions/ContextQuery/SyntaxContext.cs | 177 ++++++++---------- .../ContextQuery/VisualBasicSyntaxContext.vb | 15 ++ 6 files changed, 198 insertions(+), 136 deletions(-) diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb index 93e3d6a1af72e..3c9256fba03e2 100644 --- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb +++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb @@ -12753,5 +12753,72 @@ internal class Program Await state.AssertSelectedCompletionItem("Create") End Using End Function + + + + Public Async Function TestFilterOutOwnTypeInBaseList1(showCompletionInArgumentLists As Boolean) As Task + Using state = TestStateFactory.CreateCSharpTestState( + + class C : $$ + { + } + , + showCompletionInArgumentLists:=showCompletionInArgumentLists, languageVersion:=LanguageVersion.CSharp12) + + state.SendInvokeCompletionList() + Await state.AssertCompletionItemsDoNotContainAny("C") + End Using + End Function + + + + Public Async Function TestFilterOutOwnTypeInBaseList2(showCompletionInArgumentLists As Boolean) As Task + Using state = TestStateFactory.CreateCSharpTestState( + + class C : $$ + { + interface IGoo + { + } + } + , + showCompletionInArgumentLists:=showCompletionInArgumentLists, languageVersion:=LanguageVersion.CSharp12) + + state.SendInvokeCompletionList() + Await state.AssertCompletionItemsContain("C", displayTextSuffix:="") + End Using + End Function + + + + Public Async Function TestFilterOutOwnTypeInBaseList3(showCompletionInArgumentLists As Boolean) As Task + Using state = TestStateFactory.CreateCSharpTestState( + + class C : IComparable<$$> + { + } + , + showCompletionInArgumentLists:=showCompletionInArgumentLists, languageVersion:=LanguageVersion.CSharp12) + + state.SendInvokeCompletionList() + Await state.AssertCompletionItemsContain("C", displayTextSuffix:="") + End Using + End Function + + + + Public Async Function TestFilterOutOwnTypeInBaseList4(showCompletionInArgumentLists As Boolean) As Task + Using state = TestStateFactory.CreateCSharpTestState( + + class C : BaseType($$); + { + } + , + showCompletionInArgumentLists:=showCompletionInArgumentLists, languageVersion:=LanguageVersion.CSharp12) + + state.SendInvokeCompletionList() + Await state.AssertCompletionItemsContain("C", displayTextSuffix:="") + End Using + End Function End Class End Namespace diff --git a/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs b/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs index 603702028c112..1a4276e13ddfd 100644 --- a/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs +++ b/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs @@ -307,13 +307,26 @@ private ImmutableArray GetSymbolsForLabelContext() private ImmutableArray GetSymbolsForTypeOrNamespaceContext() { - var symbols = _context.SemanticModel.LookupNamespacesAndTypes(_context.LeftToken.SpanStart); + var semanticModel = _context.SemanticModel; + var symbols = semanticModel.LookupNamespacesAndTypes(_context.LeftToken.SpanStart); if (_context.TargetToken.IsUsingKeywordInUsingDirective()) - return symbols.WhereAsArray(s => s is INamespaceSymbol); + return symbols.WhereAsArray(static s => s is INamespaceSymbol); if (_context.TargetToken.IsStaticKeywordContextInUsingDirective()) - return symbols.WhereAsArray(s => !s.IsDelegateType()); + return symbols.WhereAsArray(static s => !s.IsDelegateType()); + + if (_context.IsBaseListContext) + { + // Filter out the type we're in the inheritance list for if it has no nested types. A type can't show + // up in its own inheritance list (unless being used to + // + // Note: IsBaseListContext requires that we have a type declaration ancestor above us.. + var containingType = semanticModel.GetRequiredDeclaredSymbol( + _context.TargetToken.GetRequiredAncestor(), _cancellationToken).OriginalDefinition; + if (containingType.GetTypeMembers().IsEmpty) + return symbols.WhereAsArray(static (s, containingType) => !Equals(s.OriginalDefinition, containingType), containingType); + } return symbols; } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/CSharpSyntaxContext.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/CSharpSyntaxContext.cs index 6608db62f781c..a1b105c643dab 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/CSharpSyntaxContext.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/CSharpSyntaxContext.cs @@ -59,6 +59,7 @@ private CSharpSyntaxContext( bool isAtStartOfPattern, bool isAttributeNameContext, bool isAwaitKeywordContext, + bool isBaseListContext, bool isCatchFilterContext, bool isConstantExpressionContext, bool isCrefContext, @@ -119,6 +120,7 @@ private CSharpSyntaxContext( isAtStartOfPattern: isAtStartOfPattern, isAttributeNameContext: isAttributeNameContext, isAwaitKeywordContext: isAwaitKeywordContext, + isBaseListContext: isBaseListContext, isEnumBaseListContext: isEnumBaseListContext, isEnumTypeMemberAccessContext: isEnumTypeMemberAccessContext, isGenericConstraintContext: isGenericConstraintContext, @@ -194,40 +196,22 @@ private static CSharpSyntaxContext CreateContextWorker( var targetToken = leftToken.GetPreviousTokenIfTouchingWord(position); - var isPreProcessorKeywordContext = isPreProcessorDirectiveContext - ? syntaxTree.IsPreProcessorKeywordContext(position, leftToken) - : false; + var isPreProcessorKeywordContext = isPreProcessorDirectiveContext && syntaxTree.IsPreProcessorKeywordContext(position, leftToken); + var isPreProcessorExpressionContext = isPreProcessorDirectiveContext && targetToken.IsPreProcessorExpressionContext(); - var isPreProcessorExpressionContext = isPreProcessorDirectiveContext - ? targetToken.IsPreProcessorExpressionContext() - : false; - - var isStatementContext = !isPreProcessorDirectiveContext - ? targetToken.IsBeginningOfStatementContext() - : false; - - var isGlobalStatementContext = !isPreProcessorDirectiveContext - ? syntaxTree.IsGlobalStatementContext(position, cancellationToken) - : false; - - var isAnyExpressionContext = !isPreProcessorDirectiveContext - ? syntaxTree.IsExpressionContext(position, leftToken, attributes: true, cancellationToken: cancellationToken, semanticModel: semanticModel) - : false; - - var isNonAttributeExpressionContext = !isPreProcessorDirectiveContext - ? syntaxTree.IsExpressionContext(position, leftToken, attributes: false, cancellationToken: cancellationToken, semanticModel: semanticModel) - : false; - - var isConstantExpressionContext = !isPreProcessorDirectiveContext - ? syntaxTree.IsConstantExpressionContext(position, leftToken) - : false; + var isStatementContext = !isPreProcessorDirectiveContext && targetToken.IsBeginningOfStatementContext(); + var isGlobalStatementContext = !isPreProcessorDirectiveContext && syntaxTree.IsGlobalStatementContext(position, cancellationToken); + var isAnyExpressionContext = !isPreProcessorDirectiveContext && syntaxTree.IsExpressionContext(position, leftToken, attributes: true, cancellationToken: cancellationToken, semanticModel: semanticModel); + var isNonAttributeExpressionContext = !isPreProcessorDirectiveContext && syntaxTree.IsExpressionContext(position, leftToken, attributes: false, cancellationToken: cancellationToken, semanticModel: semanticModel); + var isConstantExpressionContext = !isPreProcessorDirectiveContext && syntaxTree.IsConstantExpressionContext(position, leftToken); var containingTypeDeclaration = syntaxTree.GetContainingTypeDeclaration(position, cancellationToken); var containingTypeOrEnumDeclaration = syntaxTree.GetContainingTypeOrEnumDeclaration(position, cancellationToken); - var isDestructorTypeContext = targetToken.IsKind(SyntaxKind.TildeToken) && - targetToken.Parent.IsKind(SyntaxKind.DestructorDeclaration) && - targetToken.Parent.Parent is (kind: SyntaxKind.ClassDeclaration or SyntaxKind.RecordDeclaration); + var isDestructorTypeContext = + targetToken.IsKind(SyntaxKind.TildeToken) && + targetToken.Parent.IsKind(SyntaxKind.DestructorDeclaration) && + targetToken.Parent.Parent is (kind: SyntaxKind.ClassDeclaration or SyntaxKind.RecordDeclaration); // Typing a dot after a numeric expression (numericExpression.) // - maybe a start of MemberAccessExpression like numericExpression.Member. @@ -255,6 +239,7 @@ private static CSharpSyntaxContext CreateContextWorker( isAtStartOfPattern: syntaxTree.IsAtStartOfPattern(leftToken, position), isAttributeNameContext: syntaxTree.IsAttributeNameContext(position, cancellationToken), isAwaitKeywordContext: ComputeIsAwaitKeywordContext(position, leftToken, targetToken, isGlobalStatementContext, isAnyExpressionContext, isStatementContext), + isBaseListContext: syntaxTree.IsBaseListContext(targetToken), isCatchFilterContext: syntaxTree.IsCatchFilterContext(position, leftToken), isConstantExpressionContext: isConstantExpressionContext, isCrefContext: syntaxTree.IsCrefContext(position, cancellationToken) && !leftToken.IsKind(SyntaxKind.DotToken), diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs index 4e95eb1a04151..d7cd0a61f63cc 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs @@ -2985,6 +2985,19 @@ public static bool IsCatchFilterContext(this SyntaxTree syntaxTree, int position return false; } + public static bool IsBaseListContext(this SyntaxTree syntaxTree, SyntaxToken targetToken) + { + // Options: + // class E : | + // class E : i| + // class E : i, | + // class E : i, j| + + return + targetToken is (kind: SyntaxKind.ColonToken or SyntaxKind.CommaToken) && + targetToken.Parent is BaseListSyntax { Parent: TypeDeclarationSyntax }; + } + public static bool IsEnumBaseListContext(this SyntaxTree syntaxTree, SyntaxToken targetToken) { // Options: diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ContextQuery/SyntaxContext.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ContextQuery/SyntaxContext.cs index d8ca532ea6863..3285b8f39ec2e 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ContextQuery/SyntaxContext.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ContextQuery/SyntaxContext.cs @@ -9,123 +9,92 @@ namespace Microsoft.CodeAnalysis.Shared.Extensions.ContextQuery; -internal abstract class SyntaxContext +internal abstract class SyntaxContext( + Document document, + SemanticModel semanticModel, + int position, + SyntaxToken leftToken, + SyntaxToken targetToken, + bool isAnyExpressionContext, + bool isAtEndOfPattern, + bool isAtStartOfPattern, + bool isAttributeNameContext, + bool isAwaitKeywordContext, + bool isBaseListContext, + bool isEnumBaseListContext, + bool isEnumTypeMemberAccessContext, + bool isGenericConstraintContext, + bool isGlobalStatementContext, + bool isInImportsDirective, + bool isInQuery, + bool isTaskLikeTypeContext, + bool isNameOfContext, + bool isNamespaceContext, + bool isNamespaceDeclarationNameContext, + bool isObjectCreationTypeContext, + bool isOnArgumentListBracketOrComma, + bool isPossibleTupleContext, + bool isPreProcessorDirectiveContext, + bool isPreProcessorExpressionContext, + bool isRightAfterUsingOrImportDirective, + bool isRightOfNameSeparator, + bool isRightSideOfNumericType, + bool isStatementContext, + bool isTypeContext, + bool isWithinAsyncMethod, + CancellationToken cancellationToken) { - public Document Document { get; } - public SemanticModel SemanticModel { get; } - public SyntaxTree SyntaxTree { get; } - public int Position { get; } + public Document Document { get; } = document; + public SemanticModel SemanticModel { get; } = semanticModel; + public SyntaxTree SyntaxTree { get; } = semanticModel.SyntaxTree; + public int Position { get; } = position; /// /// The token to the left of . This token may be touching the position. /// - public SyntaxToken LeftToken { get; } + public SyntaxToken LeftToken { get; } = leftToken; /// /// The first token to the left of that we're not touching. Equal to /// if we aren't touching . /// - public SyntaxToken TargetToken { get; } + public SyntaxToken TargetToken { get; } = targetToken; - public bool IsAnyExpressionContext { get; } - public bool IsAtEndOfPattern { get; } - public bool IsAtStartOfPattern { get; } - public bool IsAttributeNameContext { get; } - public bool IsAwaitKeywordContext { get; } - public bool IsEnumBaseListContext { get; } - public bool IsEnumTypeMemberAccessContext { get; } - public bool IsGenericConstraintContext { get; } - public bool IsGlobalStatementContext { get; } - public bool IsInImportsDirective { get; } - public bool IsInQuery { get; } - public bool IsTaskLikeTypeContext { get; } - public bool IsNameOfContext { get; } - public bool IsNamespaceContext { get; } - public bool IsNamespaceDeclarationNameContext { get; } - public bool IsObjectCreationTypeContext { get; } - public bool IsOnArgumentListBracketOrComma { get; } - public bool IsPossibleTupleContext { get; } - public bool IsPreProcessorDirectiveContext { get; } - public bool IsPreProcessorExpressionContext { get; } - public bool IsRightAfterUsingOrImportDirective { get; } - public bool IsRightOfNameSeparator { get; } - public bool IsRightSideOfNumericType { get; } - public bool IsStatementContext { get; } - public bool IsTypeContext { get; } - public bool IsWithinAsyncMethod { get; } + public bool IsAnyExpressionContext { get; } = isAnyExpressionContext; + public bool IsAtEndOfPattern { get; } = isAtEndOfPattern; + public bool IsAtStartOfPattern { get; } = isAtStartOfPattern; + public bool IsAttributeNameContext { get; } = isAttributeNameContext; + public bool IsAwaitKeywordContext { get; } = isAwaitKeywordContext; - public ImmutableArray InferredTypes { get; } - - protected SyntaxContext( - Document document, - SemanticModel semanticModel, - int position, - SyntaxToken leftToken, - SyntaxToken targetToken, - bool isAnyExpressionContext, - bool isAtEndOfPattern, - bool isAtStartOfPattern, - bool isAttributeNameContext, - bool isAwaitKeywordContext, - bool isEnumBaseListContext, - bool isEnumTypeMemberAccessContext, - bool isGenericConstraintContext, - bool isGlobalStatementContext, - bool isInImportsDirective, - bool isInQuery, - bool isTaskLikeTypeContext, - bool isNameOfContext, - bool isNamespaceContext, - bool isNamespaceDeclarationNameContext, - bool isObjectCreationTypeContext, - bool isOnArgumentListBracketOrComma, - bool isPossibleTupleContext, - bool isPreProcessorDirectiveContext, - bool isPreProcessorExpressionContext, - bool isRightAfterUsingOrImportDirective, - bool isRightOfNameSeparator, - bool isRightSideOfNumericType, - bool isStatementContext, - bool isTypeContext, - bool isWithinAsyncMethod, - CancellationToken cancellationToken) - { - this.Document = document; - this.SemanticModel = semanticModel; - this.SyntaxTree = semanticModel.SyntaxTree; - this.Position = position; - this.LeftToken = leftToken; - this.TargetToken = targetToken; - - this.IsAnyExpressionContext = isAnyExpressionContext; - this.IsAtEndOfPattern = isAtEndOfPattern; - this.IsAtStartOfPattern = isAtStartOfPattern; - this.IsAttributeNameContext = isAttributeNameContext; - this.IsAwaitKeywordContext = isAwaitKeywordContext; - this.IsEnumBaseListContext = isEnumBaseListContext; - this.IsEnumTypeMemberAccessContext = isEnumTypeMemberAccessContext; - this.IsGenericConstraintContext = isGenericConstraintContext; - this.IsGlobalStatementContext = isGlobalStatementContext; - this.IsInImportsDirective = isInImportsDirective; - this.IsInQuery = isInQuery; - this.IsTaskLikeTypeContext = isTaskLikeTypeContext; - this.IsNameOfContext = isNameOfContext; - this.IsNamespaceContext = isNamespaceContext; - this.IsNamespaceDeclarationNameContext = isNamespaceDeclarationNameContext; - this.IsObjectCreationTypeContext = isObjectCreationTypeContext; - this.IsOnArgumentListBracketOrComma = isOnArgumentListBracketOrComma; - this.IsPossibleTupleContext = isPossibleTupleContext; - this.IsPreProcessorDirectiveContext = isPreProcessorDirectiveContext; - this.IsPreProcessorExpressionContext = isPreProcessorExpressionContext; - this.IsRightAfterUsingOrImportDirective = isRightAfterUsingOrImportDirective; - this.IsRightOfNameSeparator = isRightOfNameSeparator; - this.IsRightSideOfNumericType = isRightSideOfNumericType; - this.IsStatementContext = isStatementContext; - this.IsTypeContext = isTypeContext; - this.IsWithinAsyncMethod = isWithinAsyncMethod; + /// + /// Is in the base list of a type declaration. Note, this only counts when at the top level of the base list, not + /// *within* any type already in the base list. For example class C : $$ is in the base list. But class + /// C : A<$$> is not. + /// + public bool IsBaseListContext { get; } = isBaseListContext; + public bool IsEnumBaseListContext { get; } = isEnumBaseListContext; + public bool IsEnumTypeMemberAccessContext { get; } = isEnumTypeMemberAccessContext; + public bool IsGenericConstraintContext { get; } = isGenericConstraintContext; + public bool IsGlobalStatementContext { get; } = isGlobalStatementContext; + public bool IsInImportsDirective { get; } = isInImportsDirective; + public bool IsInQuery { get; } = isInQuery; + public bool IsTaskLikeTypeContext { get; } = isTaskLikeTypeContext; + public bool IsNameOfContext { get; } = isNameOfContext; + public bool IsNamespaceContext { get; } = isNamespaceContext; + public bool IsNamespaceDeclarationNameContext { get; } = isNamespaceDeclarationNameContext; + public bool IsObjectCreationTypeContext { get; } = isObjectCreationTypeContext; + public bool IsOnArgumentListBracketOrComma { get; } = isOnArgumentListBracketOrComma; + public bool IsPossibleTupleContext { get; } = isPossibleTupleContext; + public bool IsPreProcessorDirectiveContext { get; } = isPreProcessorDirectiveContext; + public bool IsPreProcessorExpressionContext { get; } = isPreProcessorExpressionContext; + public bool IsRightAfterUsingOrImportDirective { get; } = isRightAfterUsingOrImportDirective; + public bool IsRightOfNameSeparator { get; } = isRightOfNameSeparator; + public bool IsRightSideOfNumericType { get; } = isRightSideOfNumericType; + public bool IsStatementContext { get; } = isStatementContext; + public bool IsTypeContext { get; } = isTypeContext; + public bool IsWithinAsyncMethod { get; } = isWithinAsyncMethod; - this.InferredTypes = document.GetRequiredLanguageService().InferTypes(semanticModel, position, cancellationToken); - } + public ImmutableArray InferredTypes { get; } = document.GetRequiredLanguageService().InferTypes(semanticModel, position, cancellationToken); public TService? GetLanguageService() where TService : class, ILanguageService => Document.GetLanguageService(); diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/ContextQuery/VisualBasicSyntaxContext.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/ContextQuery/VisualBasicSyntaxContext.vb index e26e38c9bd5bd..ba8ea8c202b50 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/ContextQuery/VisualBasicSyntaxContext.vb +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/ContextQuery/VisualBasicSyntaxContext.vb @@ -56,6 +56,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions.ContextQuery targetToken As SyntaxToken, isAttributeNameContext As Boolean, isAwaitKeywordContext As Boolean, + isBaseListContext As Boolean, isCustomEventContext As Boolean, isEnumBaseListContext As Boolean, isEnumTypeMemberAccessContext As Boolean, @@ -93,6 +94,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions.ContextQuery isAtStartOfPattern:=False, isAttributeNameContext:=isAttributeNameContext, isAwaitKeywordContext:=isAwaitKeywordContext, + isBaseListContext:=isBaseListContext, isEnumBaseListContext:=isEnumBaseListContext, isEnumTypeMemberAccessContext:=isEnumTypeMemberAccessContext, isGenericConstraintContext:=isGenericConstraintContext, @@ -176,6 +178,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions.ContextQuery isAttributeNameContext:=syntaxTree.IsAttributeNameContext(position, targetToken, cancellationToken), isAwaitKeywordContext:=ComputeIsAwaitKeywordContext(targetToken, isAnyExpressionContext, isInQuery, isStatementContext), isCustomEventContext:=targetToken.GetAncestor(Of EventBlockSyntax)() IsNot Nothing, + isBaseListContext:=ComputeIsBaseListContext(targetToken), isEnumBaseListContext:=ComputeIsEnumBaseListContext(targetToken), isEnumTypeMemberAccessContext:=syntaxTree.IsEnumTypeMemberAccessContext(position, targetToken, semanticModel, cancellationToken), isGenericConstraintContext:=targetToken.Parent.IsKind(SyntaxKind.TypeParameterSingleConstraintClause, SyntaxKind.TypeParameterMultipleConstraintClause), @@ -231,6 +234,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions.ContextQuery Return False End If + For Each node In targetToken.GetAncestors(Of SyntaxNode)() If node.IsKind(SyntaxKind.SingleLineSubLambdaExpression, SyntaxKind.SingleLineFunctionLambdaExpression, SyntaxKind.MultiLineSubLambdaExpression, SyntaxKind.MultiLineFunctionLambdaExpression) Then @@ -284,6 +288,17 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions.ContextQuery (targetToken.HasNonContinuableEndOfLineBeforePosition(position) AndAlso Not targetToken.FollowsBadEndDirective()) End Function + Private Shared Function ComputeIsBaseListContext(targetToken As SyntaxToken) As Boolean + If targetToken.Kind() = SyntaxKind.ImplementsKeyword OrElse + targetToken.Kind() = SyntaxKind.InheritsKeyword OrElse + targetToken.Kind() = SyntaxKind.CommaToken Then + Dim parent = TryCast(targetToken.Parent, InheritsOrImplementsStatementSyntax) + Return parent IsNot Nothing + End If + + Return False + End Function + Private Shared Function ComputeIsEnumBaseListContext(targetToken As SyntaxToken) As Boolean Dim enumDeclaration = targetToken.GetAncestor(Of EnumStatementSyntax)() Return enumDeclaration IsNot Nothing AndAlso From 00977b1d3d78c8eb766f2cd4560778fdf2855a22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?= Date: Thu, 23 Jan 2025 12:41:16 -0800 Subject: [PATCH 37/76] Improve handling bad metadata in EE (#76878) --- Roslyn.sln | 2 +- .../CSharpExpressionCompiler.cs | 36 +++--- .../CSharpInstructionDecoder.cs | 8 +- .../CompilationExtensions.cs | 29 ++--- .../ExpressionCompiler/EvaluationContext.cs | 30 ++--- .../ExpressionCompilerTestBase.cs | 50 ++++----- .../ExpressionCompilerTests.cs | 57 +++++----- .../HoistedStateMachineLocalTests.cs | 8 +- .../InstructionDecoderTests.cs | 5 +- .../Test/ExpressionCompiler/LocalsTests.cs | 6 +- .../MethodContextReuseConstraintsTests.cs | 18 +-- ...CSharp.ExpressionCompiler.UnitTests.csproj | 2 +- .../MissingAssemblyTests.cs | 12 +- .../ReferencedModulesTests.cs | 92 +++++++-------- .../BadMetadataModuleException.cs | 16 +++ .../Source/ExpressionCompiler/DkmUtilities.cs | 16 +-- .../ExpressionCompiler/ExpressionCompiler.cs | 106 ++++++++++++------ .../Source/ExpressionCompiler/FrameDecoder.cs | 13 ++- .../LanguageInstructionDecoder.cs | 2 +- .../ExpressionCompiler/MetadataBlock.cs | 14 +-- .../ExpressionCompiler/MetadataContextId.cs | 4 +- .../ExpressionCompiler/MetadataUtilities.cs | 12 +- .../MethodContextReuseConstraints.cs | 17 ++- .../Source/ExpressionCompiler/ModuleId.cs | 20 ++++ .../ExpressionCompilerTestHelpers.cs | 13 ++- ....ExpressionCompiler.Test.Utilities.csproj} | 0 .../Test/ExpressionCompiler/ModuleInstance.cs | 20 ++-- .../CompilationExtensions.vb | 28 ++--- .../ExpressionCompiler/EvaluationContext.vb | 26 ++--- .../VisualBasicExpressionCompiler.vb | 34 +++--- .../VisualBasicInstructionDecoder.vb | 8 +- .../ExpressionCompilerTestBase.vb | 46 ++++---- .../ExpressionCompilerTests.vb | 60 +++++----- .../HoistedStateMachineLocalTests.vb | 8 +- .../InstructionDecoderTests.vb | 2 +- .../Test/ExpressionCompiler/LocalsTests.vb | 6 +- ...lBasic.ExpressionCompiler.UnitTests.vbproj | 2 +- .../MissingAssemblyTests.vb | 8 +- .../ReferencedModulesTests.vb | 64 +++++------ .../ExpressionCompiler/StaticLocalsTests.vb | 10 +- 40 files changed, 501 insertions(+), 409 deletions(-) create mode 100644 src/ExpressionEvaluator/Core/Source/ExpressionCompiler/BadMetadataModuleException.cs create mode 100644 src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ModuleId.cs rename src/ExpressionEvaluator/Core/Test/ExpressionCompiler/{Microsoft.CodeAnalysis.ExpressionCompiler.Utilities.csproj => Microsoft.CodeAnalysis.ExpressionCompiler.Test.Utilities.csproj} (100%) diff --git a/Roslyn.sln b/Roslyn.sln index 07332ef370408..c49637445381e 100644 --- a/Roslyn.sln +++ b/Roslyn.sln @@ -205,7 +205,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Expr EndProject Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.ResultProvider.UnitTests", "src\ExpressionEvaluator\VisualBasic\Test\ResultProvider\Microsoft.CodeAnalysis.VisualBasic.ResultProvider.UnitTests.vbproj", "{ACE53515-482C-4C6A-E2D2-4242A687DFEE}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ExpressionCompiler.Utilities", "src\ExpressionEvaluator\Core\Test\ExpressionCompiler\Microsoft.CodeAnalysis.ExpressionCompiler.Utilities.csproj", "{21B80A31-8FF9-4E3A-8403-AABD635AEED9}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ExpressionCompiler.Test.Utilities", "src\ExpressionEvaluator\Core\Test\ExpressionCompiler\Microsoft.CodeAnalysis.ExpressionCompiler.Test.Utilities.csproj", "{21B80A31-8FF9-4E3A-8403-AABD635AEED9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ResultProvider.Utilities", "src\ExpressionEvaluator\Core\Test\ResultProvider\Microsoft.CodeAnalysis.ResultProvider.Utilities.csproj", "{ABDBAC1E-350E-4DC3-BB45-3504404545EE}" EndProject diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpExpressionCompiler.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpExpressionCompiler.cs index d69d5dd1828ad..312654b1db780 100644 --- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpExpressionCompiler.cs +++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpExpressionCompiler.cs @@ -33,10 +33,11 @@ internal override DkmCompilerId CompilerId internal delegate MetadataContext GetMetadataContextDelegate(TAppDomain appDomain); internal delegate void SetMetadataContextDelegate(TAppDomain appDomain, MetadataContext metadataContext, bool report); + /// Module wasn't included in the compilation due to bad metadata. internal override EvaluationContextBase CreateTypeContext( DkmClrAppDomain appDomain, ImmutableArray metadataBlocks, - Guid moduleVersionId, + ModuleId moduleId, int typeToken, bool useReferencedModulesOnly) { @@ -44,16 +45,17 @@ internal override EvaluationContextBase CreateTypeContext( appDomain, ad => ad.GetMetadataContext(), metadataBlocks, - moduleVersionId, + moduleId, typeToken, GetMakeAssemblyReferencesKind(useReferencedModulesOnly)); } + /// Module wasn't included in the compilation due to bad metadata. internal static EvaluationContext CreateTypeContext( TAppDomain appDomain, GetMetadataContextDelegate getMetadataContext, ImmutableArray metadataBlocks, - Guid moduleVersionId, + ModuleId moduleId, int typeToken, MakeAssemblyReferencesKind kind) { @@ -63,14 +65,14 @@ internal static EvaluationContext CreateTypeContext( { // Avoid using the cache for referenced assemblies only // since this should be the exceptional case. - compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleVersionId); + compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleId); return EvaluationContext.CreateTypeContext( compilation, - moduleVersionId, + moduleId, typeToken); } - var contextId = MetadataContextId.GetContextId(moduleVersionId, kind); + var contextId = MetadataContextId.GetContextId(moduleId, kind); var previous = getMetadataContext(appDomain); CSharpMetadataContext previousMetadataContext = default; if (previous.Matches(metadataBlocks)) @@ -80,11 +82,11 @@ internal static EvaluationContext CreateTypeContext( // Re-use the previous compilation if possible. compilation = previousMetadataContext.Compilation; - compilation ??= metadataBlocks.ToCompilation(moduleVersionId, kind); + compilation ??= metadataBlocks.ToCompilation(moduleId, kind); var context = EvaluationContext.CreateTypeContext( compilation, - moduleVersionId, + moduleId, typeToken); // New type context is not attached to the AppDomain since it is less @@ -101,7 +103,7 @@ internal override EvaluationContextBase CreateMethodContext( ImmutableArray metadataBlocks, Lazy> unusedLazyAssemblyReaders, object? symReader, - Guid moduleVersionId, + ModuleId moduleId, int methodToken, int methodVersion, uint ilOffset, @@ -114,7 +116,7 @@ internal override EvaluationContextBase CreateMethodContext( (ad, mc, report) => ad.SetMetadataContext(mc, report), metadataBlocks, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -128,7 +130,7 @@ internal static EvaluationContext CreateMethodContext( SetMetadataContextDelegate setMetadataContext, ImmutableArray metadataBlocks, object? symReader, - Guid moduleVersionId, + ModuleId moduleId, int methodToken, int methodVersion, uint ilOffset, @@ -142,18 +144,18 @@ internal static EvaluationContext CreateMethodContext( { // Avoid using the cache for referenced assemblies only // since this should be the exceptional case. - compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleVersionId); + compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleId); return EvaluationContext.CreateMethodContext( compilation, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, offset, localSignatureToken); } - var contextId = MetadataContextId.GetContextId(moduleVersionId, kind); + var contextId = MetadataContextId.GetContextId(moduleId, kind); var previous = getMetadataContext(appDomain); var assemblyContexts = previous.Matches(metadataBlocks) ? previous.AssemblyContexts : ImmutableDictionary.Empty; CSharpMetadataContext previousMetadataContext; @@ -167,20 +169,20 @@ internal static EvaluationContext CreateMethodContext( var previousContext = previousMetadataContext.EvaluationContext; if (previousContext != null && previousContext.MethodContextReuseConstraints.HasValue && - previousContext.MethodContextReuseConstraints.GetValueOrDefault().AreSatisfied(moduleVersionId, methodToken, methodVersion, offset)) + previousContext.MethodContextReuseConstraints.GetValueOrDefault().AreSatisfied(moduleId, methodToken, methodVersion, offset)) { return previousContext; } } else { - compilation = metadataBlocks.ToCompilation(moduleVersionId, kind); + compilation = metadataBlocks.ToCompilation(moduleId, kind); } var context = EvaluationContext.CreateMethodContext( compilation, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, offset, diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs index bd7334fbd67cf..f401de6dea6b4 100644 --- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs +++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs @@ -151,12 +151,12 @@ internal override ImmutableArray GetAllTypeParameters(Metho internal override CSharpCompilation GetCompilation(DkmClrModuleInstance moduleInstance) { var appDomain = moduleInstance.AppDomain; - var moduleVersionId = moduleInstance.Mvid; + var moduleId = moduleInstance.GetModuleId(); var previous = appDomain.GetMetadataContext(); var metadataBlocks = moduleInstance.RuntimeInstance.GetMetadataBlocks(appDomain, previous.MetadataBlocks); var kind = GetMakeAssemblyReferencesKind(); - var contextId = MetadataContextId.GetContextId(moduleVersionId, kind); + var contextId = MetadataContextId.GetContextId(moduleId, kind); var assemblyContexts = previous.Matches(metadataBlocks) ? previous.AssemblyContexts : ImmutableDictionary.Empty; CSharpMetadataContext previousContext; assemblyContexts.TryGetValue(contextId, out previousContext); @@ -164,7 +164,7 @@ internal override CSharpCompilation GetCompilation(DkmClrModuleInstance moduleIn var compilation = previousContext.Compilation; if (compilation == null) { - compilation = metadataBlocks.ToCompilation(moduleVersionId, kind); + compilation = metadataBlocks.ToCompilation(moduleId, kind); appDomain.SetMetadataContext( new MetadataContext( metadataBlocks, @@ -178,7 +178,7 @@ internal override CSharpCompilation GetCompilation(DkmClrModuleInstance moduleIn internal override MethodSymbol GetMethod(CSharpCompilation compilation, DkmClrInstructionAddress instructionAddress) { var methodHandle = (MethodDefinitionHandle)MetadataTokens.Handle(instructionAddress.MethodId.Token); - return compilation.GetSourceMethod(instructionAddress.ModuleInstance.Mvid, methodHandle); + return compilation.GetSourceMethod(instructionAddress.ModuleInstance.GetModuleId(), methodHandle); } internal override TypeNameDecoder GetTypeNameDecoder(CSharpCompilation compilation, MethodSymbol method) diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationExtensions.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationExtensions.cs index 66a924a798140..226b7413c3c22 100644 --- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationExtensions.cs +++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationExtensions.cs @@ -24,14 +24,15 @@ private static PENamedTypeSymbol GetType(PEModuleSymbol module, TypeDefinitionHa return (PENamedTypeSymbol)metadataDecoder.GetTypeOfToken(typeHandle); } - internal static PENamedTypeSymbol GetType(this CSharpCompilation compilation, Guid moduleVersionId, int typeToken) + /// Module wasn't included in the compilation due to bad metadata. + internal static PENamedTypeSymbol GetType(this CSharpCompilation compilation, ModuleId moduleId, int typeToken) { - return GetType(compilation.GetModule(moduleVersionId), (TypeDefinitionHandle)MetadataTokens.Handle(typeToken)); + return GetType(compilation.GetModule(moduleId), (TypeDefinitionHandle)MetadataTokens.Handle(typeToken)); } - internal static PEMethodSymbol GetSourceMethod(this CSharpCompilation compilation, Guid moduleVersionId, MethodDefinitionHandle methodHandle) + internal static PEMethodSymbol GetSourceMethod(this CSharpCompilation compilation, ModuleId moduleId, MethodDefinitionHandle methodHandle) { - var method = GetMethod(compilation, moduleVersionId, methodHandle); + var method = GetMethod(compilation, moduleId, methodHandle); var metadataDecoder = new MetadataDecoder((PEModuleSymbol)method.ContainingModule); var containingType = method.ContainingType; if (GeneratedNameParser.TryParseSourceMethodNameFromGeneratedName(containingType.Name, GeneratedNameKind.StateMachineType, out var sourceMethodName)) @@ -49,9 +50,10 @@ internal static PEMethodSymbol GetSourceMethod(this CSharpCompilation compilatio return method; } - internal static PEMethodSymbol GetMethod(this CSharpCompilation compilation, Guid moduleVersionId, MethodDefinitionHandle methodHandle) + /// Module wasn't included in the compilation due to bad metadata. + internal static PEMethodSymbol GetMethod(this CSharpCompilation compilation, ModuleId moduleId, MethodDefinitionHandle methodHandle) { - var module = compilation.GetModule(moduleVersionId); + var module = compilation.GetModule(moduleId); var reader = module.Module.MetadataReader; var typeHandle = reader.GetMethodDefinition(methodHandle).GetDeclaringType(); var type = GetType(module, typeHandle); @@ -59,7 +61,8 @@ internal static PEMethodSymbol GetMethod(this CSharpCompilation compilation, Gui return method; } - internal static PEModuleSymbol GetModule(this CSharpCompilation compilation, Guid moduleVersionId) + /// Module wasn't included in the compilation due to bad metadata. + internal static PEModuleSymbol GetModule(this CSharpCompilation compilation, ModuleId moduleId) { foreach (var pair in compilation.GetBoundReferenceManager().GetReferencedAssemblies()) { @@ -68,24 +71,24 @@ internal static PEModuleSymbol GetModule(this CSharpCompilation compilation, Gui { var m = (PEModuleSymbol)module; var id = m.Module.GetModuleVersionIdOrThrow(); - if (id == moduleVersionId) + if (id == moduleId.Id) { return m; } } } - throw new ArgumentException($"No module found with MVID '{moduleVersionId}'", nameof(moduleVersionId)); + throw new BadMetadataModuleException(moduleId); } - internal static CSharpCompilation ToCompilationReferencedModulesOnly(this ImmutableArray metadataBlocks, Guid moduleVersionId) + internal static CSharpCompilation ToCompilationReferencedModulesOnly(this ImmutableArray metadataBlocks, ModuleId moduleId) { - return ToCompilation(metadataBlocks, moduleVersionId, kind: MakeAssemblyReferencesKind.DirectReferencesOnly); + return ToCompilation(metadataBlocks, moduleId, kind: MakeAssemblyReferencesKind.DirectReferencesOnly); } - internal static CSharpCompilation ToCompilation(this ImmutableArray metadataBlocks, Guid moduleVersionId, MakeAssemblyReferencesKind kind) + internal static CSharpCompilation ToCompilation(this ImmutableArray metadataBlocks, ModuleId moduleId, MakeAssemblyReferencesKind kind) { - var references = metadataBlocks.MakeAssemblyReferences(moduleVersionId, IdentityComparer, kind, out var referencesBySimpleName); + var references = metadataBlocks.MakeAssemblyReferences(moduleId, IdentityComparer, kind, out var referencesBySimpleName); var options = s_compilationOptions; if (referencesBySimpleName != null) { diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs index 7e32529042d3b..008ed555c6854 100644 --- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs +++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs @@ -64,20 +64,21 @@ private EvaluationContext( /// Create a context for evaluating expressions at a type scope. /// /// Compilation. - /// Module containing type + /// Module containing type /// Type metadata token /// Evaluation context /// /// No locals since locals are associated with methods, not types. /// + /// Module wasn't included in the compilation due to bad metadata. internal static EvaluationContext CreateTypeContext( CSharpCompilation compilation, - Guid moduleVersionId, + ModuleId moduleId, int typeToken) { Debug.Assert(MetadataTokens.Handle(typeToken).Kind == HandleKind.TypeDefinition); - var currentType = compilation.GetType(moduleVersionId, typeToken); + var currentType = compilation.GetType(moduleId, typeToken); RoslynDebug.Assert(currentType is object); var currentFrame = new SynthesizedContextMethodSymbol(currentType); return new EvaluationContext( @@ -94,9 +95,8 @@ internal static EvaluationContext CreateTypeContext( /// Create a context for evaluating expressions within a method scope. /// /// Module metadata - /// for PDB associated with - /// Module containing method - /// Method metadata token + /// for PDB associated with + /// Module containing method /// Method version. /// IL offset of instruction pointer in method /// Method local signature token @@ -104,7 +104,7 @@ internal static EvaluationContext CreateTypeContext( internal static EvaluationContext CreateMethodContext( ImmutableArray metadataBlocks, object symReader, - Guid moduleVersionId, + ModuleId moduleId, int methodToken, int methodVersion, uint ilOffset, @@ -112,12 +112,12 @@ internal static EvaluationContext CreateMethodContext( { var offset = NormalizeILOffset(ilOffset); - var compilation = metadataBlocks.ToCompilation(moduleVersionId: default, MakeAssemblyReferencesKind.AllAssemblies); + var compilation = metadataBlocks.ToCompilation(moduleId: default, MakeAssemblyReferencesKind.AllAssemblies); return CreateMethodContext( compilation, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, offset, @@ -128,8 +128,8 @@ internal static EvaluationContext CreateMethodContext( /// Create a context for evaluating expressions within a method scope. /// /// Compilation. - /// for PDB associated with - /// Module containing method + /// for PDB associated with + /// Module containing method /// Method metadata token /// Method version. /// IL offset of instruction pointer in method @@ -138,17 +138,17 @@ internal static EvaluationContext CreateMethodContext( internal static EvaluationContext CreateMethodContext( CSharpCompilation compilation, object? symReader, - Guid moduleVersionId, + ModuleId moduleId, int methodToken, int methodVersion, int ilOffset, int localSignatureToken) { var methodHandle = (MethodDefinitionHandle)MetadataTokens.Handle(methodToken); - var currentSourceMethod = compilation.GetSourceMethod(moduleVersionId, methodHandle); + var currentSourceMethod = compilation.GetSourceMethod(moduleId, methodHandle); var localSignatureHandle = (localSignatureToken != 0) ? (StandaloneSignatureHandle)MetadataTokens.Handle(localSignatureToken) : default; - var currentFrame = compilation.GetMethod(moduleVersionId, methodHandle); + var currentFrame = compilation.GetMethod(moduleId, methodHandle); RoslynDebug.AssertNotNull(currentFrame); var symbolProvider = new CSharpEESymbolProvider(compilation.SourceAssembly, (PEModuleSymbol)currentFrame.ContainingModule, currentFrame); @@ -174,7 +174,7 @@ internal static EvaluationContext CreateMethodContext( localsBuilder.AddRange(debugInfo.LocalConstants); return new EvaluationContext( - new MethodContextReuseConstraints(moduleVersionId, methodToken, methodVersion, reuseSpan), + new MethodContextReuseConstraints(moduleId, methodToken, methodVersion, reuseSpan), compilation, currentFrame, currentSourceMethod, diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTestBase.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTestBase.cs index 5f42d90e82458..230bf3926c994 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTestBase.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTestBase.cs @@ -136,7 +136,7 @@ internal void RemoveMetadataContext() internal static EvaluationContext CreateTypeContext( AppDomain appDomain, ImmutableArray blocks, - Guid moduleVersionId, + ModuleId moduleId, int typeToken, MakeAssemblyReferencesKind kind = MakeAssemblyReferencesKind.AllAssemblies) { @@ -144,7 +144,7 @@ internal static EvaluationContext CreateTypeContext( appDomain, ad => ad.GetMetadataContext(), blocks, - moduleVersionId, + moduleId, typeToken, kind); } @@ -153,7 +153,7 @@ internal static EvaluationContext CreateMethodContext( AppDomain appDomain, ImmutableArray blocks, ISymUnmanagedReader symReader, - Guid moduleVersionId, + ModuleId moduleId, int methodToken, int methodVersion, uint ilOffset, @@ -166,7 +166,7 @@ internal static EvaluationContext CreateMethodContext( (ad, mc, report) => ad.SetMetadataContext(mc), blocks, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -177,14 +177,14 @@ internal static EvaluationContext CreateMethodContext( internal static EvaluationContext CreateMethodContext( AppDomain appDomain, ImmutableArray blocks, - (Guid ModuleVersionId, ISymUnmanagedReader SymReader, int MethodToken, int LocalSignatureToken, uint ILOffset) state, + (ModuleId ModuleId, ISymUnmanagedReader SymReader, int MethodToken, int LocalSignatureToken, uint ILOffset) state, MakeAssemblyReferencesKind kind = MakeAssemblyReferencesKind.AllReferences) { return CreateMethodContext( appDomain, blocks, state.SymReader, - state.ModuleVersionId, + state.ModuleId, state.MethodToken, methodVersion: 1, state.ILOffset, @@ -192,10 +192,10 @@ internal static EvaluationContext CreateMethodContext( kind); } - internal static CSharpMetadataContext GetMetadataContext(MetadataContext appDomainContext, Guid mvid = default) + internal static CSharpMetadataContext GetMetadataContext(MetadataContext appDomainContext, ModuleId moduleId = default) { var assemblyContexts = appDomainContext.AssemblyContexts; - return assemblyContexts != null && assemblyContexts.TryGetValue(new MetadataContextId(mvid), out CSharpMetadataContext context) + return assemblyContexts != null && assemblyContexts.TryGetValue(new MetadataContextId(moduleId.Id), out CSharpMetadataContext context) ? context : default; } @@ -207,9 +207,9 @@ internal static MetadataContext SetMetadataContext(Metada appDomainContext.AssemblyContexts.SetItem(new MetadataContextId(mvid), context)); } - internal static (Guid ModuleVersionId, ISymUnmanagedReader SymReader, int MethodToken, int LocalSignatureToken, uint ILOffset) GetContextState(RuntimeInstance runtime, string methodName) + internal static (ModuleId ModuleId, ISymUnmanagedReader SymReader, int MethodToken, int LocalSignatureToken, uint ILOffset) GetContextState(RuntimeInstance runtime, string methodName) { - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int methodToken; int localSignatureToken; @@ -217,19 +217,19 @@ internal static (Guid ModuleVersionId, ISymUnmanagedReader SymReader, int Method runtime, methodName, out _, - out moduleVersionId, + out moduleId, out symReader, out methodToken, out localSignatureToken); uint ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader); - return (moduleVersionId, symReader, methodToken, localSignatureToken, ilOffset); + return (moduleId, symReader, methodToken, localSignatureToken, ilOffset); } internal static void GetContextState( RuntimeInstance runtime, string methodOrTypeName, out ImmutableArray blocks, - out Guid moduleVersionId, + out ModuleId moduleId, out ISymUnmanagedReader symReader, out int methodOrTypeToken, out int localSignatureToken) @@ -237,15 +237,15 @@ internal static void GetContextState( var moduleInstances = runtime.Modules; blocks = moduleInstances.SelectAsArray(m => m.MetadataBlock); - var compilation = blocks.ToCompilation(default(Guid), MakeAssemblyReferencesKind.AllAssemblies); + var compilation = blocks.ToCompilation(new ModuleId(id: default, "test"), MakeAssemblyReferencesKind.AllAssemblies); var methodOrType = GetMethodOrTypeBySignature(compilation, methodOrTypeName); var module = (PEModuleSymbol)methodOrType.ContainingModule; - var id = module.Module.GetModuleVersionIdOrThrow(); - var moduleInstance = moduleInstances.First(m => m.ModuleVersionId == id); + var mvid = module.Module.GetModuleVersionIdOrThrow(); + var moduleInstance = moduleInstances.First(m => m.Id.Id == mvid); - moduleVersionId = id; + moduleId = moduleInstance.Id; symReader = (ISymUnmanagedReader)moduleInstance.SymReader; EntityHandle methodOrTypeHandle; @@ -270,11 +270,11 @@ internal static EvaluationContext CreateMethodContext( int atLineNumber = -1) { ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int methodToken; int localSignatureToken; - GetContextState(runtime, methodName, out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, methodName, out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); uint ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader, atLineNumber); @@ -282,7 +282,7 @@ internal static EvaluationContext CreateMethodContext( new AppDomain(), blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ilOffset, @@ -295,15 +295,15 @@ internal static EvaluationContext CreateTypeContext( string typeName) { ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int typeToken; int localSignatureToken; - GetContextState(runtime, typeName, out blocks, out moduleVersionId, out symReader, out typeToken, out localSignatureToken); + GetContextState(runtime, typeName, out blocks, out moduleId, out symReader, out typeToken, out localSignatureToken); return CreateTypeContext( new AppDomain(), blocks, - moduleVersionId, + moduleId, typeToken, kind: MakeAssemblyReferencesKind.AllAssemblies); } @@ -508,11 +508,11 @@ internal static Alias Alias(DkmClrAliasKind kind, string name, string fullName, internal static MethodDebugInfo GetMethodDebugInfo(RuntimeInstance runtime, string qualifiedMethodName, int ilOffset = 0) { - var peCompilation = runtime.Modules.SelectAsArray(m => m.MetadataBlock).ToCompilation(default(Guid), MakeAssemblyReferencesKind.AllAssemblies); + var peCompilation = runtime.Modules.SelectAsArray(m => m.MetadataBlock).ToCompilation(moduleId: default, MakeAssemblyReferencesKind.AllAssemblies); var peMethod = peCompilation.GlobalNamespace.GetMember(qualifiedMethodName); var peModule = (PEModuleSymbol)peMethod.ContainingModule; - var symReader = runtime.Modules.Single(mi => mi.ModuleVersionId == peModule.Module.GetModuleVersionIdOrThrow()).SymReader; + var symReader = runtime.Modules.Single(mi => mi.Id.Id == peModule.Module.GetModuleVersionIdOrThrow()).SymReader; var symbolProvider = new CSharpEESymbolProvider(peCompilation.SourceAssembly, peModule, peMethod); return MethodDebugInfo.ReadMethodDebugInfo((ISymUnmanagedReader3)symReader, symbolProvider, MetadataTokens.GetToken(peMethod.Handle), methodVersion: 1, ilOffset: ilOffset, isVisualBasicMethod: false); diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs index 704fe62aeb1f5..5ed458adb7962 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs @@ -46,12 +46,7 @@ static void M() var compilation0 = CreateCompilation(source, options: TestOptions.DebugDll); WithRuntimeInstance(compilation0, runtime => { - ImmutableArray blocks; - Guid moduleVersionId; - ISymUnmanagedReader symReader; - int methodToken; - int localSignatureToken; - GetContextState(runtime, "C.M", out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "C.M", out var blocks, out var moduleVersionId, out var symReader, out var methodToken, out var localSignatureToken); var appDomain = new AppDomain(); uint ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader); @@ -341,13 +336,13 @@ static void G() var runtime = CreateRuntimeInstance(moduleB, referencesB); ImmutableArray typeBlocks; ImmutableArray methodBlocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int typeToken; int methodToken; int localSignatureToken; - GetContextState(runtime, "C", out typeBlocks, out moduleVersionId, out symReader, out typeToken, out localSignatureToken); - GetContextState(runtime, "C.F", out methodBlocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "C", out typeBlocks, out moduleId, out symReader, out typeToken, out localSignatureToken); + GetContextState(runtime, "C.F", out methodBlocks, out moduleId, out symReader, out methodToken, out localSignatureToken); // Get non-empty scopes. var scopes = symReader.GetScopes(methodToken, methodVersion, EvaluationContext.IsLocalScopeEndInclusive).WhereAsArray(s => s.Locals.Length > 0); @@ -358,16 +353,16 @@ static void G() endOffset = outerScope.EndOffset - 1; // At start of outer scope. - var context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleVersionId, methodToken, methodVersion, (uint)startOffset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); + var context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleId, methodToken, methodVersion, (uint)startOffset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); // At end of outer scope - not reused because of the nested scope. var previous = appDomain.GetMetadataContext(); - context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleVersionId, methodToken, methodVersion, (uint)endOffset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); + context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleId, methodToken, methodVersion, (uint)endOffset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext); // Not required, just documentary. // At type context. previous = appDomain.GetMetadataContext(); - context = CreateTypeContext(appDomain, typeBlocks, moduleVersionId, typeToken, MakeAssemblyReferencesKind.AllAssemblies); + context = CreateTypeContext(appDomain, typeBlocks, moduleId, typeToken, MakeAssemblyReferencesKind.AllAssemblies); Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext); Assert.Null(context.MethodContextReuseConstraints); Assert.Equal(context.Compilation, GetMetadataContext(previous).Compilation); @@ -381,10 +376,10 @@ static void G() var constraints = GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints; if (constraints.HasValue) { - Assert.Equal(scope == previousScope, constraints.GetValueOrDefault().AreSatisfied(moduleVersionId, methodToken, methodVersion, offset)); + Assert.Equal(scope == previousScope, constraints.GetValueOrDefault().AreSatisfied(moduleId, methodToken, methodVersion, offset)); } - context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleVersionId, methodToken, methodVersion, (uint)offset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); + context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleId, methodToken, methodVersion, (uint)offset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); var previousEvaluationContext = GetMetadataContext(previous).EvaluationContext; if (scope == previousScope) { @@ -407,20 +402,20 @@ static void G() // With different references. var fewerReferences = new[] { MscorlibRef }; runtime = CreateRuntimeInstance(moduleB, fewerReferences); - GetContextState(runtime, "C.F", out methodBlocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "C.F", out methodBlocks, out moduleId, out symReader, out methodToken, out localSignatureToken); // Different references. No reuse. - context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleVersionId, methodToken, methodVersion, (uint)endOffset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); + context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleId, methodToken, methodVersion, (uint)endOffset, localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext); - Assert.True(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleVersionId, methodToken, methodVersion, endOffset)); + Assert.True(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleId, methodToken, methodVersion, endOffset)); Assert.NotEqual(context.Compilation, GetMetadataContext(previous).Compilation); previous = appDomain.GetMetadataContext(); // Different method. Should reuse Compilation. - GetContextState(runtime, "C.G", out methodBlocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); - context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleVersionId, methodToken, methodVersion, ilOffset: 0, localSignatureToken: localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); + GetContextState(runtime, "C.G", out methodBlocks, out moduleId, out symReader, out methodToken, out localSignatureToken); + context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleId, methodToken, methodVersion, ilOffset: 0, localSignatureToken: localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext); - Assert.False(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleVersionId, methodToken, methodVersion, 0)); + Assert.False(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleId, methodToken, methodVersion, 0)); Assert.Equal(context.Compilation, GetMetadataContext(previous).Compilation); // No EvaluationContext. Should reuse Compilation @@ -428,7 +423,7 @@ static void G() previous = appDomain.GetMetadataContext(); Assert.Null(GetMetadataContext(previous).EvaluationContext); Assert.NotNull(GetMetadataContext(previous).Compilation); - context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleVersionId, methodToken, methodVersion, ilOffset: 0, localSignatureToken: localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); + context = CreateMethodContext(appDomain, methodBlocks, symReader, moduleId, methodToken, methodVersion, ilOffset: 0, localSignatureToken: localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies); Assert.Null(GetMetadataContext(previous).EvaluationContext); Assert.NotNull(context); Assert.Equal(context.Compilation, GetMetadataContext(previous).Compilation); @@ -5602,7 +5597,7 @@ static void M() using (var pinnedMetadata = new PinnedBlob(TestResources.ExpressionCompiler.NoValidTables)) { - var corruptMetadata = ModuleInstance.Create(pinnedMetadata.Pointer, pinnedMetadata.Size, default(Guid)); + var corruptMetadata = ModuleInstance.Create(pinnedMetadata.Pointer, pinnedMetadata.Size, id: default); var runtime = RuntimeInstance.Create(new[] { corruptMetadata, comp.ToModuleInstance(), MscorlibRef.ToModuleInstance() }); var context = CreateMethodContext(runtime, "C.M"); @@ -6032,11 +6027,11 @@ public static void M() var runtime = CreateRuntimeInstance(module, new[] { MscorlibRef, ExpressionCompilerTestHelpers.IntrinsicAssemblyReference }); ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader2; int methodToken; int localSignatureToken; - GetContextState(runtime, "C.M", out blocks, out moduleVersionId, out symReader2, out methodToken, out localSignatureToken); + GetContextState(runtime, "C.M", out blocks, out moduleId, out symReader2, out methodToken, out localSignatureToken); Assert.Same(symReader, symReader2); @@ -6047,7 +6042,7 @@ public static void M() new AppDomain(), blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: 0, @@ -6067,7 +6062,7 @@ public static void M() new AppDomain(), blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 2, ilOffset: 0, @@ -6265,18 +6260,18 @@ static void M(int x) WithRuntimeInstance(compilation0, runtime => { ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int methodToken; int localSignatureToken; - GetContextState(runtime, "C.M", out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "C.M", out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); var appDomain = new AppDomain(); var context = CreateMethodContext( appDomain, blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ExpressionCompilerTestHelpers.NoILOffset, @@ -6302,7 +6297,7 @@ .locals init (int V_0) //y appDomain, blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: 0, @@ -6315,7 +6310,7 @@ .locals init (int V_0) //y appDomain, blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ExpressionCompilerTestHelpers.NoILOffset, diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/HoistedStateMachineLocalTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/HoistedStateMachineLocalTests.cs index dea8f37c45f2b..8b28a453aa30b 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/HoistedStateMachineLocalTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/HoistedStateMachineLocalTests.cs @@ -1343,11 +1343,11 @@ static IEnumerable M() WithRuntimeInstance(compilation0, runtime => { ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int methodToken; int localSignatureToken; - GetContextState(runtime, "C.d__0.MoveNext", out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "C.d__0.MoveNext", out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); var appDomain = new AppDomain(); uint ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader, atLineNumber: 100); @@ -1355,7 +1355,7 @@ static IEnumerable M() appDomain, blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ilOffset, @@ -1373,7 +1373,7 @@ static IEnumerable M() appDomain, blocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ilOffset, diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs index 296b53939144b..b08988356335a 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs @@ -594,7 +594,7 @@ private CSharpCompilation CreateCompilation(string source) var runtime = CreateRuntimeInstance(compilation); var moduleInstances = runtime.Modules; var blocks = moduleInstances.SelectAsArray(m => m.MetadataBlock); - return blocks.ToCompilation(default(Guid), MakeAssemblyReferencesKind.AllAssemblies); + return blocks.ToCompilation(new ModuleId(id: default, compilation.AssemblyName), MakeAssemblyReferencesKind.AllAssemblies); } private MethodSymbol GetConstructedMethod(CSharpCompilation compilation, PEMethodSymbol frame, string[] serializedTypeArgumentNames, CSharpInstructionDecoder instructionDecoder) @@ -603,8 +603,9 @@ private MethodSymbol GetConstructedMethod(CSharpCompilation compilation, PEMetho // using the same helper as the product code. This helper will also map // async/iterator "MoveNext" methods to the original source method. MethodSymbol method = compilation.GetSourceMethod( - ((PEModuleSymbol)frame.ContainingModule).Module.GetModuleVersionIdOrThrow(), + new ModuleId(((PEModuleSymbol)frame.ContainingModule).Module.GetModuleVersionIdOrThrow(), compilation.AssemblyName), frame.Handle); + if (serializedTypeArgumentNames != null) { Assert.NotEmpty(serializedTypeArgumentNames); diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs index 27c357e83e38b..b79db1b87fdbe 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs @@ -5128,11 +5128,11 @@ private static void GetLocals(RuntimeInstance runtime, string methodName, bool a private static void GetLocals(RuntimeInstance runtime, string methodName, MethodDebugInfoBytes debugInfo, ArrayBuilder locals, int count) { ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader unused; int methodToken; int localSignatureToken; - GetContextState(runtime, methodName, out blocks, out moduleVersionId, out unused, out methodToken, out localSignatureToken); + GetContextState(runtime, methodName, out blocks, out moduleId, out unused, out methodToken, out localSignatureToken); var symReader = new MockSymUnmanagedReader( new Dictionary() @@ -5143,7 +5143,7 @@ private static void GetLocals(RuntimeInstance runtime, string methodName, Method new AppDomain(), blocks, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion: 1, ilOffset: 0, diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MethodContextReuseConstraintsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MethodContextReuseConstraintsTests.cs index e3dd509f76a46..85d0197eb3df1 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MethodContextReuseConstraintsTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MethodContextReuseConstraintsTests.cs @@ -16,26 +16,26 @@ public class MethodContextReuseConstraintsTests : ExpressionCompilerTestBase [Fact] public void AreSatisfied() { - var moduleVersionId = Guid.NewGuid(); + var moduleId = new ModuleId(Guid.NewGuid(), "module"); const int methodToken = 0x06000001; const int methodVersion = 1; const uint startOffset = 1; const uint endOffsetExclusive = 3; var constraints = new MethodContextReuseConstraints( - moduleVersionId, + moduleId, methodToken, methodVersion, new ILSpan(startOffset, endOffsetExclusive)); - Assert.True(constraints.AreSatisfied(moduleVersionId, methodToken, methodVersion, (int)startOffset)); - Assert.True(constraints.AreSatisfied(moduleVersionId, methodToken, methodVersion, (int)endOffsetExclusive - 1)); + Assert.True(constraints.AreSatisfied(moduleId, methodToken, methodVersion, (int)startOffset)); + Assert.True(constraints.AreSatisfied(moduleId, methodToken, methodVersion, (int)endOffsetExclusive - 1)); - Assert.False(constraints.AreSatisfied(Guid.NewGuid(), methodToken, methodVersion, (int)startOffset)); - Assert.False(constraints.AreSatisfied(moduleVersionId, methodToken + 1, methodVersion, (int)startOffset)); - Assert.False(constraints.AreSatisfied(moduleVersionId, methodToken, methodVersion + 1, (int)startOffset)); - Assert.False(constraints.AreSatisfied(moduleVersionId, methodToken, methodVersion, (int)startOffset - 1)); - Assert.False(constraints.AreSatisfied(moduleVersionId, methodToken, methodVersion, (int)endOffsetExclusive)); + Assert.False(constraints.AreSatisfied(new ModuleId(Guid.NewGuid(), "module"), methodToken, methodVersion, (int)startOffset)); + Assert.False(constraints.AreSatisfied(moduleId, methodToken + 1, methodVersion, (int)startOffset)); + Assert.False(constraints.AreSatisfied(moduleId, methodToken, methodVersion + 1, (int)startOffset)); + Assert.False(constraints.AreSatisfied(moduleId, methodToken, methodVersion, (int)startOffset - 1)); + Assert.False(constraints.AreSatisfied(moduleId, methodToken, methodVersion, (int)endOffsetExclusive)); } [Fact] diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.UnitTests.csproj b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.UnitTests.csproj index e38edfef0f10b..ba668ee2a1d90 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.UnitTests.csproj +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.UnitTests.csproj @@ -14,7 +14,7 @@ - + diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MissingAssemblyTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MissingAssemblyTests.cs index 1b0cce7b9beb0..2a1b5564ebd61 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MissingAssemblyTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/MissingAssemblyTests.cs @@ -663,6 +663,7 @@ void M() uSize = (uint)missingModule.MetadataLength; return missingModule.MetadataAddress; }, + out _, out errorMessage); Assert.Equal(2, numRetries); // Ensure that we actually retried and that we bailed out on the second retry if the same identity was seen in the diagnostics. @@ -690,7 +691,7 @@ void M() var shouldSucceed = false; string errorMessage; - var compileResult = ExpressionCompilerTestHelpers.CompileExpressionWithRetry( + ExpressionCompilerTestHelpers.CompileExpressionWithRetry( runtime.Modules.Select(m => m.MetadataBlock).ToImmutableArray(), context, (_, diagnostics) => @@ -711,6 +712,7 @@ void M() uSize = (uint)missingModule.MetadataLength; return missingModule.MetadataAddress; }, + out var compileResult, out errorMessage); Assert.Same(TestCompileResult.Instance, compileResult); @@ -902,11 +904,11 @@ private static void TupleContextNoSystemRuntime(string source, string methodName WithRuntimeInstance(comp, [Net461.References.mscorlib, ValueTupleLegacyRef], runtime => { ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int methodToken; int localSignatureToken; - GetContextState(runtime, methodName, out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, methodName, out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); string errorMessage; CompilationTestData testData; int retryCount = 0; @@ -915,9 +917,9 @@ private static void TupleContextNoSystemRuntime(string source, string methodName expression, ImmutableArray.Empty, (b, u) => EvaluationContext.CreateMethodContext( - b.ToCompilation(default(Guid), MakeAssemblyReferencesKind.AllAssemblies), + b.ToCompilation(moduleId: default, MakeAssemblyReferencesKind.AllAssemblies), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion: 1, ilOffset: 0, diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs index 9b86934ebdc21..733ed84419182 100644 --- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs +++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs @@ -164,7 +164,7 @@ .maxstack 1 context = EvaluationContext.CreateMethodContext( allBlocks, stateA1.SymReader, - stateA1.ModuleVersionId, + stateA1.ModuleId, stateA1.MethodToken, methodVersion: 1, stateA1.ILOffset, @@ -185,7 +185,7 @@ .maxstack 1 context = EvaluationContext.CreateMethodContext( allBlocks, stateA1.SymReader, - stateA1.ModuleVersionId, + stateA1.ModuleId, stateA1.MethodToken, methodVersion: 1, uint.MaxValue, @@ -371,10 +371,10 @@ public void ReuseCompilation() var stateB1 = GetContextState(runtime, "B1.M"); var stateB2 = GetContextState(runtime, "B2.M"); - var mvidA1 = stateA1.ModuleVersionId; - var mvidA2 = stateA2.ModuleVersionId; - var mvidB1 = stateB1.ModuleVersionId; - Assert.Equal(mvidB1, stateB2.ModuleVersionId); + var mvidA1 = stateA1.ModuleId; + var mvidA2 = stateA2.ModuleId; + var mvidB1 = stateB1.ModuleId; + Assert.Equal(mvidB1, stateB2.ModuleId); EvaluationContext context; MetadataContext previous; @@ -452,9 +452,9 @@ public void ReuseCompilation() } } - private static void VerifyAppDomainMetadataContext(AppDomain appDomain, params Guid[] moduleVersionIds) + private static void VerifyAppDomainMetadataContext(AppDomain appDomain, params ModuleId[] moduleIds) { - ExpressionCompilerTestHelpers.VerifyAppDomainMetadataContext(appDomain.GetMetadataContext(), moduleVersionIds); + ExpressionCompilerTestHelpers.VerifyAppDomainMetadataContext(appDomain.GetMetadataContext(), moduleIds); } [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26159")] @@ -630,13 +630,13 @@ static void M() { ImmutableArray typeBlocks; ImmutableArray methodBlocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int typeToken; int methodToken; int localSignatureToken; - GetContextState(runtime, "C", out typeBlocks, out moduleVersionId, out symReader, out typeToken, out localSignatureToken); - GetContextState(runtime, "C.M", out methodBlocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "C", out typeBlocks, out moduleId, out symReader, out typeToken, out localSignatureToken); + GetContextState(runtime, "C.M", out methodBlocks, out moduleId, out symReader, out methodToken, out localSignatureToken); uint ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader); // Compile expression with type context with all modules. @@ -644,7 +644,7 @@ static void M() var context = CreateTypeContext( appDomain, typeBlocks, - moduleVersionId, + moduleId, typeToken, MakeAssemblyReferencesKind.AllAssemblies); @@ -670,7 +670,7 @@ static void M() context = CreateTypeContext( appDomain, typeBlocks, - moduleVersionId, + moduleId, typeToken, MakeAssemblyReferencesKind.DirectReferencesOnly); // A is unrecognized since there were no direct references to AS1 or AS2. @@ -711,7 +711,7 @@ .maxstack 1 appDomain, methodBlocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ilOffset, @@ -734,7 +734,7 @@ .maxstack 1 appDomain, methodBlocks, symReader, - moduleVersionId, + moduleId, methodToken: methodToken, methodVersion: 1, ilOffset: ilOffset, @@ -797,11 +797,11 @@ private static void VerifyAssemblyReferences( var modules = references.SelectAsArray(r => r.ToModuleInstance()); using (var runtime = new RuntimeInstance(modules, DebugInformationFormat.Pdb)) { - var moduleVersionId = target.GetModuleVersionId(); + var moduleId = new ModuleId(target.GetModuleVersionId(), target.Display ?? ""); var blocks = runtime.Modules.SelectAsArray(m => m.MetadataBlock); IReadOnlyDictionary> referencesBySimpleName; - var actualReferences = blocks.MakeAssemblyReferences(moduleVersionId, CompilationExtensions.IdentityComparer, MakeAssemblyReferencesKind.DirectReferencesOnly, out referencesBySimpleName); + var actualReferences = blocks.MakeAssemblyReferences(moduleId, CompilationExtensions.IdentityComparer, MakeAssemblyReferencesKind.DirectReferencesOnly, out referencesBySimpleName); Assert.Null(referencesBySimpleName); // Verify identities. var actualIdentities = actualReferences.SelectAsArray(r => r.GetAssemblyIdentity()); @@ -810,9 +810,9 @@ private static void VerifyAssemblyReferences( var uniqueIdentities = actualIdentities.Distinct(); Assert.Equal(actualIdentities.Length, uniqueIdentities.Length); - actualReferences = blocks.MakeAssemblyReferences(moduleVersionId, CompilationExtensions.IdentityComparer, MakeAssemblyReferencesKind.AllReferences, out referencesBySimpleName); + actualReferences = blocks.MakeAssemblyReferences(moduleId, CompilationExtensions.IdentityComparer, MakeAssemblyReferencesKind.AllReferences, out referencesBySimpleName); Assert.Equal(2, actualReferences.Length); - Assert.Equal(moduleVersionId, actualReferences[1].GetModuleVersionId()); + Assert.Equal(moduleId.Id, actualReferences[1].GetModuleVersionId()); foreach (var reference in references) { var identity = reference.GetAssemblyIdentity(); @@ -879,15 +879,15 @@ static void M() var runtime = CreateRuntimeInstance(new[] { MscorlibRef.ToModuleInstance(), SystemCoreRef.ToModuleInstance(), moduleA, moduleB }); ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int typeToken; int methodToken; int localSignatureToken; - GetContextState(runtime, "B", out blocks, out moduleVersionId, out symReader, out typeToken, out localSignatureToken); + GetContextState(runtime, "B", out blocks, out moduleId, out symReader, out typeToken, out localSignatureToken); string errorMessage; CompilationTestData testData; - var contextFactory = CreateTypeContextFactory(moduleVersionId, typeToken); + var contextFactory = CreateTypeContextFactory(moduleId, typeToken); // Duplicate type in namespace, at type scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "new N.C1()", ImmutableArray.Empty, contextFactory, getMetaDataBytesPtr: null, errorMessage: out errorMessage, testData: out testData); @@ -899,8 +899,8 @@ IEnumerable CS0433Messages(string type) } Assert.Contains(errorMessage, CS0433Messages("C1")); - GetContextState(runtime, "B.M", out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); - contextFactory = CreateMethodContextFactory(moduleVersionId, symReader, methodToken, localSignatureToken); + GetContextState(runtime, "B.M", out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); + contextFactory = CreateMethodContextFactory(moduleId, symReader, methodToken, localSignatureToken); // Duplicate type in namespace, at method scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "new C1()", ImmutableArray.Empty, contextFactory, getMetaDataBytesPtr: null, errorMessage: out errorMessage, testData: out testData); @@ -915,8 +915,8 @@ IEnumerable CS0433Messages(string type) Assert.Equal($"error CS0121: {string.Format(CSharpResources.ERR_AmbigCall, "N.E.F(A)", "N.E.F(A)")}", errorMessage); // Same tests as above but in library that does not directly reference duplicates. - GetContextState(runtime, "A", out blocks, out moduleVersionId, out symReader, out typeToken, out localSignatureToken); - contextFactory = CreateTypeContextFactory(moduleVersionId, typeToken); + GetContextState(runtime, "A", out blocks, out moduleId, out symReader, out typeToken, out localSignatureToken); + contextFactory = CreateTypeContextFactory(moduleId, typeToken); // Duplicate type in namespace, at type scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "new N.C1()", ImmutableArray.Empty, contextFactory, getMetaDataBytesPtr: null, errorMessage: out errorMessage, testData: out testData); @@ -931,8 +931,8 @@ .maxstack 1 }"); Assert.Equal(((MethodSymbol)methodData.Method).ReturnType.ContainingAssembly.ToDisplayString(), identityA.GetDisplayName()); - GetContextState(runtime, "A.M", out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); - contextFactory = CreateMethodContextFactory(moduleVersionId, symReader, methodToken, localSignatureToken); + GetContextState(runtime, "A.M", out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); + contextFactory = CreateMethodContextFactory(moduleId, symReader, methodToken, localSignatureToken); // Duplicate type in global namespace, at method scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "new C2()", ImmutableArray.Empty, contextFactory, getMetaDataBytesPtr: null, errorMessage: out errorMessage, testData: out testData); @@ -1013,11 +1013,11 @@ class C }); ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int typeToken; int localSignatureToken; - GetContextState(runtime, "C", out blocks, out moduleVersionId, out symReader, out typeToken, out localSignatureToken); + GetContextState(runtime, "C", out blocks, out moduleId, out symReader, out typeToken, out localSignatureToken); string errorMessage; CompilationTestData testData; int attempts = 0; @@ -1025,8 +1025,8 @@ EvaluationContextBase contextFactory(ImmutableArray b, bool u) { attempts++; return EvaluationContext.CreateTypeContext( - ToCompilation(b, u, moduleVersionId), - moduleVersionId, + ToCompilation(b, u, moduleId), + moduleId, typeToken); } @@ -1178,11 +1178,11 @@ static void M(A a) }); ImmutableArray blocks; - Guid moduleVersionId; + ModuleId moduleId; ISymUnmanagedReader symReader; int methodToken; int localSignatureToken; - GetContextState(runtime, "B.M", out blocks, out moduleVersionId, out symReader, out methodToken, out localSignatureToken); + GetContextState(runtime, "B.M", out blocks, out moduleId, out symReader, out methodToken, out localSignatureToken); var aliases = ImmutableArray.Create( ExceptionAlias(typeof(ArgumentException)), @@ -1194,9 +1194,9 @@ EvaluationContextBase contextFactory(ImmutableArray b, bool u) { attempts++; return EvaluationContext.CreateMethodContext( - ToCompilation(b, u, moduleVersionId), + ToCompilation(b, u, moduleId), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion: 1, ilOffset: 0, @@ -1296,7 +1296,7 @@ public class Void : Object { } var metadata = reader.GetMetadata(); var module = metadata.ToModuleMetadata(ignoreAssemblyRefs: true); var metadataReader = metadata.ToMetadataReader(); - var moduleInstance = ModuleInstance.Create(metadata, metadataReader.GetModuleVersionIdOrThrow()); + var moduleInstance = ModuleInstance.Create(metadata, new ModuleId(metadataReader.GetModuleVersionIdOrThrow(), module.Name)); // Verify the module declares System.Object. Assert.True(metadataReader.DeclaresTheObjectClass()); @@ -1416,7 +1416,7 @@ public class Void : Object { } var metadata = reader.GetMetadata(); var module = metadata.ToModuleMetadata(ignoreAssemblyRefs: true); var metadataReader = metadata.ToMetadataReader(); - var moduleInstance = ModuleInstance.Create(metadata, metadataReader.GetModuleVersionIdOrThrow(), symReader); + var moduleInstance = ModuleInstance.Create(metadata, new ModuleId(metadataReader.GetModuleVersionIdOrThrow(), module.Name), symReader); // Verify the module declares System.Object. Assert.True(metadataReader.DeclaresTheObjectClass()); @@ -1488,25 +1488,25 @@ .maxstack 1 } private static ExpressionCompiler.CreateContextDelegate CreateTypeContextFactory( - Guid moduleVersionId, + ModuleId moduleId, int typeToken) { return (blocks, useReferencedModulesOnly) => EvaluationContext.CreateTypeContext( - ToCompilation(blocks, useReferencedModulesOnly, moduleVersionId), - moduleVersionId, + ToCompilation(blocks, useReferencedModulesOnly, moduleId), + moduleId, typeToken); } private static ExpressionCompiler.CreateContextDelegate CreateMethodContextFactory( - Guid moduleVersionId, + ModuleId moduleId, ISymUnmanagedReader symReader, int methodToken, int localSignatureToken) { return (blocks, useReferencedModulesOnly) => EvaluationContext.CreateMethodContext( - ToCompilation(blocks, useReferencedModulesOnly, moduleVersionId), + ToCompilation(blocks, useReferencedModulesOnly, moduleId), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion: 1, ilOffset: 0, @@ -1516,9 +1516,9 @@ private static ExpressionCompiler.CreateContextDelegate CreateMethodContextFacto private static CSharpCompilation ToCompilation( ImmutableArray blocks, bool useReferencedModulesOnly, - Guid moduleVersionId) + ModuleId moduleId) { - return blocks.ToCompilation(moduleVersionId, useReferencedModulesOnly ? MakeAssemblyReferencesKind.DirectReferencesOnly : MakeAssemblyReferencesKind.AllAssemblies); + return blocks.ToCompilation(moduleId, useReferencedModulesOnly ? MakeAssemblyReferencesKind.DirectReferencesOnly : MakeAssemblyReferencesKind.AllAssemblies); } private sealed class PEAssemblyBuilderWithAdditionalReferences : PEModuleBuilder, IAssemblyReference diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/BadMetadataModuleException.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/BadMetadataModuleException.cs new file mode 100644 index 0000000000000..a6eca0167dbfc --- /dev/null +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/BadMetadataModuleException.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace Microsoft.CodeAnalysis.ExpressionEvaluator; + +/// +/// Thrown when trying to evaluate within a module that was not loaded due to bad metadata. +/// +internal sealed class BadMetadataModuleException(ModuleId moduleId) + : Exception($"Unable to evaluate within module '{moduleId.DisplayName}' ({moduleId.Id}): the module metadata is invalid.") +{ + public ModuleId ModuleId { get; } = moduleId; +} diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/DkmUtilities.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/DkmUtilities.cs index d74d15bdb955e..38639903bc862 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/DkmUtilities.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/DkmUtilities.cs @@ -86,7 +86,7 @@ internal static ImmutableArray GetMetadataBlocks( continue; } - Debug.Assert(block.ModuleVersionId == module.Mvid); + Debug.Assert(block.ModuleId.Id == module.Mvid); builder.Add(block); index++; } @@ -177,9 +177,10 @@ private static unsafe bool TryGetMetadataBlock(IntPtr ptr, uint size, out Metada { var reader = new MetadataReader((byte*)ptr, (int)size); var moduleDef = reader.GetModuleDefinition(); - var moduleVersionId = reader.GetGuid(moduleDef.Mvid); + var name = reader.GetString(moduleDef.Name); + var mvid = reader.GetGuid(moduleDef.Mvid); var generationId = reader.GetGuid(moduleDef.GenerationId); - block = new MetadataBlock(moduleVersionId, generationId, ptr, (int)size); + block = new MetadataBlock(new ModuleId(mvid, name), generationId, ptr, (int)size); return true; } catch (BadImageFormatException) @@ -217,17 +218,12 @@ private static bool TryGetMetadataBlock(ImmutableArray previousMe return clrModule.GetSymUnmanagedReader(); } - internal static DkmCompiledClrInspectionQuery? ToQueryResult( - this CompileResult? compResult, + internal static DkmCompiledClrInspectionQuery ToQueryResult( + this CompileResult compResult, DkmCompilerId languageId, ResultProperties resultProperties, DkmClrRuntimeInstance runtimeInstance) { - if (compResult == null) - { - return null; - } - Debug.Assert(compResult.Assembly != null); ReadOnlyCollection? customTypeInfo; diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.cs index 8eed0705b271a..efc3d3308e14d 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.cs @@ -6,6 +6,7 @@ using System.Collections.Immutable; using System.Collections.ObjectModel; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.IO; using System.Threading; using Microsoft.CodeAnalysis.PooledObjects; @@ -53,8 +54,8 @@ DkmCompiledClrLocalsQuery IDkmClrExpressionCompiler.GetClrLocalVariableQuery( var aliases = argumentsOnly ? ImmutableArray.Empty : GetAliases(runtimeInstance, inspectionContext); // NB: Not affected by retrying. - string? error; - var r = CompileWithRetry( + + if (TryCompileWithRetry( moduleInstance.AppDomain, runtimeInstance, (blocks, useReferencedModulesOnly) => CreateMethodContext(instructionAddress, blocks, useReferencedModulesOnly), @@ -73,8 +74,14 @@ DkmCompiledClrLocalsQuery IDkmClrExpressionCompiler.GetClrLocalVariableQuery( builder.Free(); return new GetLocalsResult(typeName, locals, assembly); }, - out error); - return DkmCompiledClrLocalsQuery.Create(runtimeInstance, null, CompilerId, r.Assembly, r.TypeName, r.Locals); + out var result, + out var error)) + { + return DkmCompiledClrLocalsQuery.Create(runtimeInstance, null, CompilerId, result.Assembly, result.TypeName, result.Locals); + } + + // TODO: better error reporting to the debugger (https://github.com/dotnet/roslyn/issues/76887) + throw new BadImageFormatException(error); } catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e)) { @@ -116,7 +123,8 @@ void IDkmClrExpressionCompiler.CompileExpression( var moduleInstance = instructionAddress.ModuleInstance; var runtimeInstance = instructionAddress.RuntimeInstance; var aliases = GetAliases(runtimeInstance, inspectionContext); // NB: Not affected by retrying. - var r = CompileWithRetry( + + if (TryCompileWithRetry( moduleInstance.AppDomain, runtimeInstance, (blocks, useReferencedModulesOnly) => CreateMethodContext(instructionAddress, blocks, useReferencedModulesOnly), @@ -131,8 +139,15 @@ void IDkmClrExpressionCompiler.CompileExpression( testData: null); return new CompileExpressionResult(compileResult, resultProperties); }, - out error); - result = r.CompileResult.ToQueryResult(CompilerId, r.ResultProperties, runtimeInstance); + out var r, + out error)) + { + result = r.CompileResult?.ToQueryResult(CompilerId, r.ResultProperties, runtimeInstance); + } + else + { + result = null; + } } catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e)) { @@ -152,7 +167,8 @@ void IDkmClrExpressionCompiler.CompileAssignment( var moduleInstance = instructionAddress.ModuleInstance; var runtimeInstance = instructionAddress.RuntimeInstance; var aliases = GetAliases(runtimeInstance, lValue.InspectionContext); // NB: Not affected by retrying. - var r = CompileWithRetry( + + if (TryCompileWithRetry( moduleInstance.AppDomain, runtimeInstance, (blocks, useReferencedModulesOnly) => CreateMethodContext(instructionAddress, blocks, useReferencedModulesOnly), @@ -170,13 +186,19 @@ void IDkmClrExpressionCompiler.CompileAssignment( testData: null); return new CompileExpressionResult(compileResult, resultProperties); }, - out error); - - Debug.Assert( - r.CompileResult == null && r.ResultProperties.Flags == default || - (r.ResultProperties.Flags & DkmClrCompilationResultFlags.PotentialSideEffect) == DkmClrCompilationResultFlags.PotentialSideEffect); + out var r, + out error)) + { + Debug.Assert( + r.CompileResult == null && r.ResultProperties.Flags == default || + (r.ResultProperties.Flags & DkmClrCompilationResultFlags.PotentialSideEffect) == DkmClrCompilationResultFlags.PotentialSideEffect); - result = r.CompileResult.ToQueryResult(CompilerId, r.ResultProperties, runtimeInstance); + result = r.CompileResult?.ToQueryResult(CompilerId, r.ResultProperties, runtimeInstance); + } + else + { + result = null; + } } catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e)) { @@ -195,11 +217,12 @@ void IDkmClrExpressionCompilerCallback.CompileDisplayAttribute( { var runtimeInstance = moduleInstance.RuntimeInstance; var appDomain = moduleInstance.AppDomain; - var compileResult = CompileWithRetry( + + if (TryCompileWithRetry( appDomain, runtimeInstance, - (blocks, useReferencedModulesOnly) => CreateTypeContext(appDomain, blocks, moduleInstance.Mvid, token, useReferencedModulesOnly), - (context, diagnostics) => + createContext: (blocks, useReferencedModulesOnly) => CreateTypeContext(appDomain, blocks, moduleInstance.GetModuleId(), token, useReferencedModulesOnly), + compile: (context, diagnostics) => { return context.CompileExpression( expression.Text, @@ -209,8 +232,15 @@ void IDkmClrExpressionCompilerCallback.CompileDisplayAttribute( out var unusedResultProperties, testData: null); }, - out error); - result = compileResult.ToQueryResult(CompilerId, resultProperties: default, runtimeInstance); + out var r, + out error)) + { + result = r.ToQueryResult(CompilerId, resultProperties: default, runtimeInstance); + } + else + { + result = null; + } } catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e)) { @@ -301,7 +331,7 @@ private void RemoveDataItemIfNecessary(DkmModuleInstance moduleInstance) internal abstract EvaluationContextBase CreateTypeContext( DkmClrAppDomain appDomain, ImmutableArray metadataBlocks, - Guid moduleVersionId, + ModuleId moduleId, int typeToken, bool useReferencedModulesOnly); @@ -310,7 +340,7 @@ internal abstract EvaluationContextBase CreateMethodContext( ImmutableArray metadataBlocks, Lazy> lazyAssemblyReaders, object? symReader, - Guid moduleVersionId, + ModuleId moduleId, int methodToken, int methodVersion, uint ilOffset, @@ -348,9 +378,9 @@ private EvaluationContextBase CreateMethodContext( return CreateMethodContext( moduleInstance.AppDomain, metadataBlocks, - new Lazy>(() => instructionAddress.MakeAssemblyReaders(), LazyThreadSafetyMode.None), + new Lazy>(instructionAddress.MakeAssemblyReaders, LazyThreadSafetyMode.None), symReader: moduleInstance.GetSymReader(), - moduleVersionId: moduleInstance.Mvid, + moduleId: moduleInstance.GetModuleId(), methodToken: methodToken, methodVersion: (int)instructionAddress.MethodId.Version, ilOffset: instructionAddress.ILOffset, @@ -361,41 +391,53 @@ private EvaluationContextBase CreateMethodContext( internal delegate EvaluationContextBase CreateContextDelegate(ImmutableArray metadataBlocks, bool useReferencedModulesOnly); internal delegate TResult CompileDelegate(EvaluationContextBase context, DiagnosticBag diagnostics); - private TResult CompileWithRetry( + private bool TryCompileWithRetry( DkmClrAppDomain appDomain, DkmClrRuntimeInstance runtimeInstance, CreateContextDelegate createContext, CompileDelegate compile, - out string? errorMessage) + [NotNullWhen(true)] out TResult? result, + [NotNullWhen(false)] out string? errorMessage) { var metadataBlocks = GetMetadataBlocks(appDomain, runtimeInstance); - return CompileWithRetry( + return TryCompileWithRetry( metadataBlocks, DiagnosticFormatter, createContext, compile, (AssemblyIdentity assemblyIdentity, out uint size) => appDomain.GetMetaDataBytesPtr(assemblyIdentity.GetDisplayName(), out size), + out result, out errorMessage); } - internal static TResult CompileWithRetry( + internal static bool TryCompileWithRetry( ImmutableArray metadataBlocks, DiagnosticFormatter formatter, CreateContextDelegate createContext, CompileDelegate compile, DkmUtilities.GetMetadataBytesPtrFunction getMetaDataBytesPtr, - out string? errorMessage) + [NotNullWhen(true)] out TResult? compileResult, + [NotNullWhen(false)] out string? errorMessage) { - TResult compileResult; - PooledHashSet? assembliesLoadedInRetryLoop = null; bool tryAgain; var linqLibrary = EvaluationContextBase.SystemLinqIdentity; do { + EvaluationContextBase context; + try + { + context = createContext(metadataBlocks, useReferencedModulesOnly: false); + } + catch (BadMetadataModuleException e) + { + compileResult = default; + errorMessage = e.Message; + return false; + } + errorMessage = null; - var context = createContext(metadataBlocks, useReferencedModulesOnly: false); var diagnostics = DiagnosticBag.GetInstance(); compileResult = compile(context, diagnostics); tryAgain = false; @@ -445,7 +487,7 @@ internal static TResult CompileWithRetry( } while (tryAgain); assembliesLoadedInRetryLoop?.Free(); - return compileResult; + return errorMessage == null; } private static DkmClrLocalVariableInfo ToLocalVariableInfo(LocalAndMethod local) diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/FrameDecoder.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/FrameDecoder.cs index c21fff40eeb11..aa1f81e2180fe 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/FrameDecoder.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/FrameDecoder.cs @@ -98,7 +98,18 @@ private void GetNameWithGenericTypeArguments( RoslynDebug.AssertNotNull(frame.InstructionAddress); var instructionAddress = (DkmClrInstructionAddress)frame.InstructionAddress; var compilation = _instructionDecoder.GetCompilation(instructionAddress.ModuleInstance); - var method = _instructionDecoder.GetMethod(compilation, instructionAddress); + + TMethodSymbol? method; + try + { + method = _instructionDecoder.GetMethod(compilation, instructionAddress); + } + catch (BadMetadataModuleException e) + { + onFailure(e); + return; + } + var typeParameters = _instructionDecoder.GetAllTypeParameters(method); if (!typeParameters.IsEmpty) { diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs index e8a401155f8ca..8e0cc0dc871ea 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs @@ -57,7 +57,7 @@ string IDkmLanguageInstructionDecoder.GetMethodName(DkmLanguageInstructionAddres return _instructionDecoder.GetName(method, includeParameterTypes, includeParameterNames); } } - catch (NotImplementedMetadataException) + catch (Exception e) when (e is NotImplementedMetadataException or BadMetadataModuleException) { return languageInstructionAddress.GetMethodName(argumentFlags); } diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs index d2fac14a6d6c4..afb5bde071fd5 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs @@ -15,9 +15,9 @@ namespace Microsoft.CodeAnalysis.ExpressionEvaluator internal readonly struct MetadataBlock : IEquatable { /// - /// Module version id. + /// Module id. /// - internal readonly Guid ModuleVersionId; + internal readonly ModuleId ModuleId; /// /// Module generation id. @@ -34,9 +34,9 @@ namespace Microsoft.CodeAnalysis.ExpressionEvaluator /// internal readonly int Size; - internal MetadataBlock(Guid moduleVersionId, Guid generationId, IntPtr pointer, int size) + internal MetadataBlock(ModuleId moduleId, Guid generationId, IntPtr pointer, int size) { - ModuleVersionId = moduleVersionId; + ModuleId = moduleId; GenerationId = generationId; Pointer = pointer; Size = size; @@ -46,7 +46,7 @@ public bool Equals(MetadataBlock other) { return Pointer == other.Pointer && Size == other.Size && - ModuleVersionId == other.ModuleVersionId && + ModuleId.Id == other.ModuleId.Id && GenerationId == other.GenerationId; } @@ -63,12 +63,12 @@ public override int GetHashCode() { return Hash.Combine( Hash.Combine(Pointer.GetHashCode(), Size), - Hash.Combine(ModuleVersionId.GetHashCode(), GenerationId.GetHashCode())); + Hash.Combine(ModuleId.GetHashCode(), GenerationId.GetHashCode())); } private string GetDebuggerDisplay() { - return string.Format("MetadataBlock {{ Mvid = {{{0}}}, Address = {1}, Size = {2} }}", ModuleVersionId, Pointer, Size); + return string.Format("MetadataBlock {{ Mvid = {{{0}}}, Address = {1}, Size = {2} }}", ModuleId, Pointer, Size); } } } diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataContextId.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataContextId.cs index 787990c7176a6..b4d15d2bce5f2 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataContextId.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataContextId.cs @@ -28,12 +28,12 @@ public override bool Equals(object obj) public override int GetHashCode() => ModuleVersionId.GetHashCode(); - internal static MetadataContextId GetContextId(Guid moduleVersionId, MakeAssemblyReferencesKind kind) + internal static MetadataContextId GetContextId(ModuleId moduleId, MakeAssemblyReferencesKind kind) { return kind switch { MakeAssemblyReferencesKind.AllAssemblies => default, - MakeAssemblyReferencesKind.AllReferences => new MetadataContextId(moduleVersionId), + MakeAssemblyReferencesKind.AllReferences => new MetadataContextId(moduleId.Id), _ => throw ExceptionUtilities.UnexpectedValue(kind), }; } diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataUtilities.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataUtilities.cs index 3fb1d95d561a1..71dde6191b484 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataUtilities.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataUtilities.cs @@ -20,18 +20,18 @@ internal static partial class MetadataUtilities { /// /// Group module metadata into assemblies. - /// If is set, the + /// If is set, the /// assemblies are limited to those referenced by that module. /// internal static ImmutableArray MakeAssemblyReferences( this ImmutableArray metadataBlocks, - Guid moduleVersionId, + ModuleId moduleId, AssemblyIdentityComparer identityComparer, MakeAssemblyReferencesKind kind, out IReadOnlyDictionary>? referencesBySimpleName) { - RoslynDebug.Assert(kind == MakeAssemblyReferencesKind.AllAssemblies || moduleVersionId != Guid.Empty); - RoslynDebug.Assert(moduleVersionId == Guid.Empty || identityComparer != null); + RoslynDebug.Assert(kind == MakeAssemblyReferencesKind.AllAssemblies || moduleId.Id != Guid.Empty); + RoslynDebug.Assert(moduleId.Id == Guid.Empty || identityComparer != null); // Get metadata for each module. var metadataBuilder = ArrayBuilder.GetInstance(); @@ -141,7 +141,7 @@ internal static ImmutableArray MakeAssemblyReferences( refsBySimpleName[identity.Name] = refs.Add((identity, reference)); if (targetReference == null && - reader.GetModuleVersionIdOrThrow() == moduleVersionId) + reader.GetModuleVersionIdOrThrow() == moduleId.Id) { targetReference = reference; } @@ -191,7 +191,7 @@ internal static ImmutableArray MakeAssemblyReferences( identitiesBuilder.Add(identity); if (targetModule == null && - reader.GetModuleVersionIdOrThrow() == moduleVersionId) + reader.GetModuleVersionIdOrThrow() == moduleId.Id) { targetModule = metadata; } diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MethodContextReuseConstraints.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MethodContextReuseConstraints.cs index bfa603f101369..300ec9f622811 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MethodContextReuseConstraints.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MethodContextReuseConstraints.cs @@ -7,37 +7,36 @@ using System.Diagnostics; using System.Reflection.Metadata; using System.Reflection.Metadata.Ecma335; -using Roslyn.Utilities; namespace Microsoft.CodeAnalysis.ExpressionEvaluator { internal readonly struct MethodContextReuseConstraints { - private readonly Guid _moduleVersionId; + private readonly ModuleId _moduleId; private readonly int _methodToken; private readonly int _methodVersion; private readonly ILSpan _span; - internal MethodContextReuseConstraints(Guid moduleVersionId, int methodToken, int methodVersion, ILSpan span) + internal MethodContextReuseConstraints(ModuleId moduleId, int methodToken, int methodVersion, ILSpan span) { - Debug.Assert(moduleVersionId != Guid.Empty); + Debug.Assert(moduleId.Id != Guid.Empty); Debug.Assert(MetadataTokens.Handle(methodToken).Kind == HandleKind.MethodDefinition); Debug.Assert(methodVersion >= 1); - _moduleVersionId = moduleVersionId; + _moduleId = moduleId; _methodToken = methodToken; _methodVersion = methodVersion; _span = span; } - public bool AreSatisfied(Guid moduleVersionId, int methodToken, int methodVersion, int ilOffset) + public bool AreSatisfied(ModuleId moduleId, int methodToken, int methodVersion, int ilOffset) { - Debug.Assert(moduleVersionId != Guid.Empty); + Debug.Assert(moduleId.Id != Guid.Empty); Debug.Assert(MetadataTokens.Handle(methodToken).Kind == HandleKind.MethodDefinition); Debug.Assert(methodVersion >= 1); Debug.Assert(ilOffset >= 0); - return moduleVersionId == _moduleVersionId && + return moduleId.Id == _moduleId.Id && methodToken == _methodToken && methodVersion == _methodVersion && _span.Contains(ilOffset); @@ -45,7 +44,7 @@ public bool AreSatisfied(Guid moduleVersionId, int methodToken, int methodVersio public override string ToString() { - return $"0x{_methodToken:x8}v{_methodVersion} from {_moduleVersionId} {_span}"; + return $"0x{_methodToken:x8}v{_methodVersion} from {_moduleId.Id} {_span}"; } /// diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ModuleId.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ModuleId.cs new file mode 100644 index 0000000000000..6f5589aa1771c --- /dev/null +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ModuleId.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using Microsoft.VisualStudio.Debugger.Clr; + +namespace Microsoft.CodeAnalysis.ExpressionEvaluator; + +internal readonly struct ModuleId(Guid id, string displayName) +{ + public Guid Id { get; } = id; + public string DisplayName { get; } = displayName; +} + +internal static class Extensions +{ + public static ModuleId GetModuleId(this DkmClrModuleInstance module) + => new(module.Mvid, module.FullName); +} diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs index 7838bdea83a01..03f09c05baa73 100644 --- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs +++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs @@ -241,19 +241,21 @@ internal static CompileResult CompileExpression( return result; } - internal static CompileResult CompileExpressionWithRetry( + internal static bool CompileExpressionWithRetry( ImmutableArray metadataBlocks, EvaluationContextBase context, ExpressionCompiler.CompileDelegate compile, DkmUtilities.GetMetadataBytesPtrFunction getMetaDataBytesPtr, + out CompileResult compileResult, out string errorMessage) { - return ExpressionCompiler.CompileWithRetry( + return ExpressionCompiler.TryCompileWithRetry( metadataBlocks, DebuggerDiagnosticFormatter.Instance, (blocks, useReferencedModulesOnly) => context, compile, getMetaDataBytesPtr, + out compileResult, out errorMessage); } @@ -266,7 +268,7 @@ internal static CompileResult CompileExpressionWithRetry( out string errorMessage, out CompilationTestData testData) { - var r = ExpressionCompiler.CompileWithRetry( + ExpressionCompiler.TryCompileWithRetry( metadataBlocks, DebuggerDiagnosticFormatter.Instance, createContext, @@ -284,6 +286,7 @@ internal static CompileResult CompileExpressionWithRetry( return new CompileExpressionResult(compileResult, td); }, getMetaDataBytesPtr, + out var r, out errorMessage); testData = r.TestData; return r.CompileResult; @@ -554,12 +557,12 @@ static void sort(ArrayBuilder<(AssemblyIdentity, AssemblyIdentity, int)> builder #endif } - internal static void VerifyAppDomainMetadataContext(MetadataContext metadataContext, Guid[] moduleVersionIds) + internal static void VerifyAppDomainMetadataContext(MetadataContext metadataContext, ModuleId[] moduleIds) where TAssemblyContext : struct { var actualIds = metadataContext.AssemblyContexts.Keys.Select(key => key.ModuleVersionId.ToString()).ToArray(); Array.Sort(actualIds); - var expectedIds = moduleVersionIds.Select(mvid => mvid.ToString()).ToArray(); + var expectedIds = moduleIds.Select(mvid => mvid.Id.ToString()).ToArray(); Array.Sort(expectedIds); AssertEx.Equal(expectedIds, actualIds); } diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/Microsoft.CodeAnalysis.ExpressionCompiler.Utilities.csproj b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/Microsoft.CodeAnalysis.ExpressionCompiler.Test.Utilities.csproj similarity index 100% rename from src/ExpressionEvaluator/Core/Test/ExpressionCompiler/Microsoft.CodeAnalysis.ExpressionCompiler.Utilities.csproj rename to src/ExpressionEvaluator/Core/Test/ExpressionCompiler/Microsoft.CodeAnalysis.ExpressionCompiler.Test.Utilities.csproj diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ModuleInstance.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ModuleInstance.cs index 71b52f06663aa..8625983ecad6e 100644 --- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ModuleInstance.cs +++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ModuleInstance.cs @@ -21,20 +21,20 @@ internal sealed class ModuleInstance : IDisposable internal readonly int MetadataLength; internal readonly IntPtr MetadataAddress; - internal readonly Guid ModuleVersionId; + internal readonly ModuleId Id; internal readonly object SymReader; private readonly bool _includeLocalSignatures; private ModuleInstance( Metadata metadata, - Guid moduleVersionId, + ModuleId id, int metadataLength, IntPtr metadataAddress, object symReader, bool includeLocalSignatures) { _metadataOpt = metadata; - ModuleVersionId = moduleVersionId; + Id = id; MetadataLength = metadataLength; MetadataAddress = metadataAddress; SymReader = symReader; // should be non-null if and only if there are symbols @@ -43,21 +43,21 @@ private ModuleInstance( public static unsafe ModuleInstance Create( PEMemoryBlock metadata, - Guid moduleVersionId, + ModuleId id, ISymUnmanagedReader symReader = null) { - return Create((IntPtr)metadata.Pointer, metadata.Length, moduleVersionId, symReader); + return Create((IntPtr)metadata.Pointer, metadata.Length, id, symReader); } public static ModuleInstance Create( IntPtr metadataAddress, int metadataLength, - Guid moduleVersionId, + ModuleId id, ISymUnmanagedReader symReader = null) { return new ModuleInstance( metadata: null, - moduleVersionId: moduleVersionId, + id: id, metadataLength: metadataLength, metadataAddress: metadataAddress, symReader: symReader, @@ -84,12 +84,12 @@ private static unsafe ModuleInstance Create( var assemblyMetadata = metadata as AssemblyMetadata; var moduleMetadata = (assemblyMetadata == null) ? (ModuleMetadata)metadata : assemblyMetadata.GetModules()[0]; - var moduleId = moduleMetadata.Module.GetModuleVersionIdOrThrow(); + var mvid = moduleMetadata.Module.GetModuleVersionIdOrThrow(); var metadataBlock = moduleMetadata.Module.PEReaderOpt.GetMetadata(); return new ModuleInstance( metadata, - moduleId, + new ModuleId(mvid, moduleMetadata.Module.Name), metadataBlock.Length, (IntPtr)metadataBlock.Pointer, symReader, @@ -100,7 +100,7 @@ private static unsafe ModuleInstance Create( public MetadataReference GetReference() => (_metadataOpt as AssemblyMetadata)?.GetReference() ?? ((ModuleMetadata)_metadataOpt).GetReference(); - internal MetadataBlock MetadataBlock => new MetadataBlock(ModuleVersionId, Guid.Empty, MetadataAddress, MetadataLength); + internal MetadataBlock MetadataBlock => new MetadataBlock(Id, Guid.Empty, MetadataAddress, MetadataLength); internal unsafe MetadataReader GetMetadataReader() => new MetadataReader((byte*)MetadataAddress, MetadataLength); diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/CompilationExtensions.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/CompilationExtensions.vb index 78ac4b0404922..a3c4a78c35992 100644 --- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/CompilationExtensions.vb +++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/CompilationExtensions.vb @@ -21,13 +21,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator End Function - Friend Function [GetType](compilation As VisualBasicCompilation, moduleVersionId As Guid, typeToken As Integer) As PENamedTypeSymbol - Return [GetType](compilation.GetModule(moduleVersionId), CType(MetadataTokens.Handle(typeToken), TypeDefinitionHandle)) + Friend Function [GetType](compilation As VisualBasicCompilation, moduleId As ModuleId, typeToken As Integer) As PENamedTypeSymbol + Return [GetType](compilation.GetModule(moduleId), CType(MetadataTokens.Handle(typeToken), TypeDefinitionHandle)) End Function - Friend Function GetSourceMethod(compilation As VisualBasicCompilation, moduleVersionId As Guid, methodHandle As MethodDefinitionHandle) As PEMethodSymbol - Dim method = GetMethod(compilation, moduleVersionId, methodHandle) + Friend Function GetSourceMethod(compilation As VisualBasicCompilation, moduleId As ModuleId, methodHandle As MethodDefinitionHandle) As PEMethodSymbol + Dim method = GetMethod(compilation, moduleId, methodHandle) Dim metadataDecoder = New MetadataDecoder(DirectCast(method.ContainingModule, PEModuleSymbol)) Dim containingType = method.ContainingType Dim sourceMethodName As String = Nothing @@ -47,8 +47,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator End Function - Friend Function GetMethod(compilation As VisualBasicCompilation, moduleVersionId As Guid, methodHandle As MethodDefinitionHandle) As PEMethodSymbol - Dim [module] = compilation.GetModule(moduleVersionId) + Friend Function GetMethod(compilation As VisualBasicCompilation, moduleId As ModuleId, methodHandle As MethodDefinitionHandle) As PEMethodSymbol + Dim [module] = compilation.GetModule(moduleId) Dim reader = [module].Module.MetadataReader Dim typeHandle = reader.GetMethodDefinition(methodHandle).GetDeclaringType() Dim type = [GetType]([module], typeHandle) @@ -57,35 +57,35 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator End Function - Friend Function GetModule(compilation As VisualBasicCompilation, moduleVersionId As Guid) As PEModuleSymbol + Friend Function GetModule(compilation As VisualBasicCompilation, moduleId As ModuleId) As PEModuleSymbol For Each pair In compilation.GetBoundReferenceManager().GetReferencedAssemblies() Dim assembly = DirectCast(pair.Value, AssemblySymbol) For Each [module] In assembly.Modules Dim m = DirectCast([module], PEModuleSymbol) Dim id = m.Module.GetModuleVersionIdOrThrow() - If id = moduleVersionId Then + If id = moduleId.Id Then Return m End If Next Next - Throw New ArgumentException($"No module found with MVID '{moduleVersionId}'", NameOf(moduleVersionId)) + Throw New BadMetadataModuleException(moduleId) End Function Friend Function ToCompilation(metadataBlocks As ImmutableArray(Of MetadataBlock)) As VisualBasicCompilation - Return ToCompilation(metadataBlocks, moduleVersionId:=Nothing, MakeAssemblyReferencesKind.AllAssemblies) + Return ToCompilation(metadataBlocks, moduleId:=Nothing, MakeAssemblyReferencesKind.AllAssemblies) End Function - Friend Function ToCompilationReferencedModulesOnly(metadataBlocks As ImmutableArray(Of MetadataBlock), moduleVersionId As Guid) As VisualBasicCompilation - Return ToCompilation(metadataBlocks, moduleVersionId, MakeAssemblyReferencesKind.DirectReferencesOnly) + Friend Function ToCompilationReferencedModulesOnly(metadataBlocks As ImmutableArray(Of MetadataBlock), moduleId As ModuleId) As VisualBasicCompilation + Return ToCompilation(metadataBlocks, moduleId, MakeAssemblyReferencesKind.DirectReferencesOnly) End Function - Friend Function ToCompilation(metadataBlocks As ImmutableArray(Of MetadataBlock), moduleVersionId As Guid, kind As MakeAssemblyReferencesKind) As VisualBasicCompilation + Friend Function ToCompilation(metadataBlocks As ImmutableArray(Of MetadataBlock), moduleId As ModuleId, kind As MakeAssemblyReferencesKind) As VisualBasicCompilation Dim referencesBySimpleName As IReadOnlyDictionary(Of String, ImmutableArray(Of (AssemblyIdentity, MetadataReference))) = Nothing - Dim references = metadataBlocks.MakeAssemblyReferences(moduleVersionId, IdentityComparer, kind, referencesBySimpleName) + Dim references = metadataBlocks.MakeAssemblyReferences(moduleId, IdentityComparer, kind, referencesBySimpleName) Dim options = s_compilationOptions If referencesBySimpleName IsNot Nothing Then Debug.Assert(kind = MakeAssemblyReferencesKind.AllReferences) diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb index eeeb6b15beb10..7512de0a950fd 100644 --- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb +++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb @@ -65,7 +65,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator ''' Create a context for evaluating expressions at a type scope. ''' ''' Compilation. - ''' Module containing type. + ''' Module containing type. ''' Type metadata token. ''' Evaluation context. ''' @@ -73,12 +73,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator ''' Friend Shared Function CreateTypeContext( compilation As VisualBasicCompilation, - moduleVersionId As Guid, + moduleId As ModuleId, typeToken As Integer) As EvaluationContext Debug.Assert(MetadataTokens.Handle(typeToken).Kind = HandleKind.TypeDefinition) - Dim currentType = compilation.GetType(moduleVersionId, typeToken) + Dim currentType = compilation.GetType(moduleId, typeToken) Debug.Assert(currentType IsNot Nothing) Dim currentFrame = New SynthesizedContextMethodSymbol(currentType) @@ -97,8 +97,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator ''' ''' Previous context, if any, for possible re-use. ''' Module metadata. - ''' for PDB associated with . - ''' Module containing method. + ''' for PDB associated with . + ''' Module containing method. ''' Method metadata token. ''' Method version. ''' IL offset of instruction pointer in method. @@ -109,7 +109,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator metadataBlocks As ImmutableArray(Of MetadataBlock), lazyAssemblyReaders As Lazy(Of ImmutableArray(Of AssemblyReaders)), symReader As Object, - moduleVersionId As Guid, + moduleId As ModuleId, methodToken As Integer, methodVersion As Integer, ilOffset As UInteger, @@ -123,7 +123,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator compilation, lazyAssemblyReaders, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, offset, @@ -134,8 +134,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator ''' Create a context for evaluating expressions within a method scope. ''' ''' Compilation. - ''' for PDB associated with . - ''' Module containing method. + ''' for PDB associated with . + ''' Module containing method. ''' Method metadata token. ''' Method version. ''' IL offset of instruction pointer in method. @@ -145,17 +145,17 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator compilation As VisualBasicCompilation, lazyAssemblyReaders As Lazy(Of ImmutableArray(Of AssemblyReaders)), symReader As Object, - moduleVersionId As Guid, + moduleId As ModuleId, methodToken As Integer, methodVersion As Integer, ilOffset As Integer, localSignatureToken As Integer) As EvaluationContext Dim methodHandle = CType(MetadataTokens.Handle(methodToken), MethodDefinitionHandle) - Dim currentSourceMethod = compilation.GetSourceMethod(moduleVersionId, methodHandle) + Dim currentSourceMethod = compilation.GetSourceMethod(moduleId, methodHandle) Dim localSignatureHandle = If(localSignatureToken <> 0, CType(MetadataTokens.Handle(localSignatureToken), StandaloneSignatureHandle), Nothing) - Dim currentFrame = compilation.GetMethod(moduleVersionId, methodHandle) + Dim currentFrame = compilation.GetMethod(moduleId, methodHandle) Debug.Assert(currentFrame IsNot Nothing) Dim symbolProvider = New VisualBasicEESymbolProvider(DirectCast(currentFrame.ContainingModule, PEModuleSymbol), currentFrame) @@ -190,7 +190,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator localsBuilder.AddRange(debugInfo.LocalConstants) Return New EvaluationContext( - New MethodContextReuseConstraints(moduleVersionId, methodToken, methodVersion, reuseSpan), + New MethodContextReuseConstraints(moduleId, methodToken, methodVersion, reuseSpan), compilation, currentFrame, currentSourceMethod, diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicExpressionCompiler.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicExpressionCompiler.vb index 2bcfa8361a131..899797768e5d8 100644 --- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicExpressionCompiler.vb +++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicExpressionCompiler.vb @@ -38,7 +38,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator Friend Overrides Function CreateTypeContext( appDomain As DkmClrAppDomain, metadataBlocks As ImmutableArray(Of MetadataBlock), - moduleVersionId As Guid, + moduleId As ModuleId, typeToken As Integer, useReferencedModulesOnly As Boolean) As EvaluationContextBase @@ -46,7 +46,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator appDomain, Function(ad) ad.GetMetadataContext(Of VisualBasicMetadataContext)(), metadataBlocks, - moduleVersionId, + moduleId, typeToken, GetMakeAssemblyReferencesKind(useReferencedModulesOnly)) End Function @@ -55,7 +55,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator appDomain As TAppDomain, getMetadataContext As GetMetadataContextDelegate(Of TAppDomain), metadataBlocks As ImmutableArray(Of MetadataBlock), - moduleVersionId As Guid, + moduleId As ModuleId, typeToken As Integer, kind As MakeAssemblyReferencesKind) As EvaluationContext @@ -64,14 +64,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator If kind = MakeAssemblyReferencesKind.DirectReferencesOnly Then ' Avoid using the cache for referenced assemblies only ' since this should be the exceptional case. - compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleVersionId) + compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleId) Return EvaluationContext.CreateTypeContext( compilation, - moduleVersionId, + moduleId, typeToken) End If - Dim contextId = MetadataContextId.GetContextId(moduleVersionId, kind) + Dim contextId = MetadataContextId.GetContextId(moduleId, kind) Dim previous = getMetadataContext(appDomain) Dim previousMetadataContext As VisualBasicMetadataContext = Nothing If previous.Matches(metadataBlocks) Then @@ -80,11 +80,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator ' Re-use the previous compilation if possible. compilation = If(previousMetadataContext.Compilation, - metadataBlocks.ToCompilation(moduleVersionId, kind)) + metadataBlocks.ToCompilation(moduleId, kind)) Dim context = EvaluationContext.CreateTypeContext( compilation, - moduleVersionId, + moduleId, typeToken) ' New type context is not attached to the AppDomain since it is less @@ -101,7 +101,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator metadataBlocks As ImmutableArray(Of MetadataBlock), lazyAssemblyReaders As Lazy(Of ImmutableArray(Of AssemblyReaders)), symReader As Object, - moduleVersionId As Guid, + moduleId As ModuleId, methodToken As Integer, methodVersion As Integer, ilOffset As UInteger, @@ -115,7 +115,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator metadataBlocks, lazyAssemblyReaders, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -130,7 +130,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator metadataBlocks As ImmutableArray(Of MetadataBlock), lazyAssemblyReaders As Lazy(Of ImmutableArray(Of AssemblyReaders)), symReader As Object, - moduleVersionId As Guid, + moduleId As ModuleId, methodToken As Integer, methodVersion As Integer, ilOffset As UInteger, @@ -143,19 +143,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator If kind = MakeAssemblyReferencesKind.DirectReferencesOnly Then ' Avoid using the cache for referenced assemblies only ' since this should be the exceptional case. - compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleVersionId) + compilation = metadataBlocks.ToCompilationReferencedModulesOnly(moduleId) Return EvaluationContext.CreateMethodContext( compilation, lazyAssemblyReaders, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, offset, localSignatureToken) End If - Dim contextId = MetadataContextId.GetContextId(moduleVersionId, kind) + Dim contextId = MetadataContextId.GetContextId(moduleId, kind) Dim previous = getMetadataContext(appDomain) Dim assemblyContexts = If(previous.Matches(metadataBlocks), previous.AssemblyContexts, ImmutableDictionary(Of MetadataContextId, VisualBasicMetadataContext).Empty) Dim previousMetadataContext As VisualBasicMetadataContext = Nothing @@ -168,18 +168,18 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator Dim previousContext = previousMetadataContext.EvaluationContext If previousContext IsNot Nothing AndAlso previousContext.MethodContextReuseConstraints.HasValue AndAlso - previousContext.MethodContextReuseConstraints.GetValueOrDefault().AreSatisfied(moduleVersionId, methodToken, methodVersion, offset) Then + previousContext.MethodContextReuseConstraints.GetValueOrDefault().AreSatisfied(moduleId, methodToken, methodVersion, offset) Then Return previousContext End If Else - compilation = metadataBlocks.ToCompilation(moduleVersionId, kind) + compilation = metadataBlocks.ToCompilation(moduleId, kind) End If Dim context = EvaluationContext.CreateMethodContext( compilation, lazyAssemblyReaders, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, offset, diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb index f4e8c8f128f3e..d36a4d64168fe 100644 --- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb +++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb @@ -90,19 +90,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator Friend Overrides Function GetCompilation(moduleInstance As DkmClrModuleInstance) As VisualBasicCompilation Dim appDomain = moduleInstance.AppDomain - Dim moduleVersionId = moduleInstance.Mvid + Dim moduleId = moduleInstance.GetModuleId() Dim previous = appDomain.GetMetadataContext(Of VisualBasicMetadataContext)() Dim metadataBlocks = moduleInstance.RuntimeInstance.GetMetadataBlocks(appDomain, previous.MetadataBlocks) Dim kind = GetMakeAssemblyReferencesKind() - Dim contextId = MetadataContextId.GetContextId(moduleVersionId, kind) + Dim contextId = MetadataContextId.GetContextId(moduleId, kind) Dim assemblyContexts = If(previous.Matches(metadataBlocks), previous.AssemblyContexts, ImmutableDictionary(Of MetadataContextId, VisualBasicMetadataContext).Empty) Dim previousContext As VisualBasicMetadataContext = Nothing assemblyContexts.TryGetValue(contextId, previousContext) Dim compilation = previousContext.Compilation If compilation Is Nothing Then - compilation = metadataBlocks.ToCompilation(moduleVersionId, kind) + compilation = metadataBlocks.ToCompilation(moduleId, kind) appDomain.SetMetadataContext( New MetadataContext(Of VisualBasicMetadataContext)( metadataBlocks, @@ -115,7 +115,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator Friend Overrides Function GetMethod(compilation As VisualBasicCompilation, instructionAddress As DkmClrInstructionAddress) As MethodSymbol Dim methodHandle = CType(MetadataTokens.Handle(instructionAddress.MethodId.Token), MethodDefinitionHandle) - Return compilation.GetSourceMethod(instructionAddress.ModuleInstance.Mvid, methodHandle) + Return compilation.GetSourceMethod(instructionAddress.ModuleInstance.GetModuleId(), methodHandle) End Function Friend Overrides Function GetTypeNameDecoder(compilation As VisualBasicCompilation, method As MethodSymbol) As TypeNameDecoder(Of PEModuleSymbol, TypeSymbol) diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTestBase.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTestBase.vb index 59d89d033e287..dc6c949e11817 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTestBase.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTestBase.vb @@ -98,23 +98,23 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests Friend Shared Function GetContextState( runtime As RuntimeInstance, - methodName As String) As (ModuleVersionId As Guid, SymReader As ISymUnmanagedReader, MethodToken As Integer, LocalSignatureToken As Integer, ILOffset As UInteger) + methodName As String) As (ModuleId As ModuleId, SymReader As ISymUnmanagedReader, MethodToken As Integer, LocalSignatureToken As Integer, ILOffset As UInteger) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim methodToken As Integer Dim localSignatureToken As Integer - GetContextState(runtime, methodName, blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, methodName, blocks, moduleId, symReader, methodToken, localSignatureToken) Dim ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader) - Return (moduleVersionId, symReader, methodToken, localSignatureToken, ilOffset) + Return (moduleId, symReader, methodToken, localSignatureToken, ilOffset) End Function Friend Shared Sub GetContextState( runtime As RuntimeInstance, methodOrTypeName As String, ByRef blocks As ImmutableArray(Of MetadataBlock), - ByRef moduleVersionId As Guid, + ByRef moduleId As ModuleId, ByRef symReader As ISymUnmanagedReader, ByRef methodOrTypeToken As Integer, ByRef localSignatureToken As Integer) @@ -125,10 +125,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests Dim compilation = blocks.ToCompilation() Dim methodOrType = GetMethodOrTypeBySignature(compilation, methodOrTypeName) Dim [module] = DirectCast(methodOrType.ContainingModule, PEModuleSymbol) - Dim id = [module].Module.GetModuleVersionIdOrThrow() - Dim moduleInstance = moduleInstances.First(Function(m) m.ModuleVersionId = id) + Dim mvid = [module].Module.GetModuleVersionIdOrThrow() + Dim moduleInstance = moduleInstances.First(Function(m) m.Id.Id = mvid) - moduleVersionId = id + moduleId = moduleInstance.Id symReader = DirectCast(moduleInstance.SymReader, ISymUnmanagedReader) Dim methodOrTypeHandle As EntityHandle @@ -163,7 +163,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests Friend Shared Function CreateTypeContext( appDomain As AppDomain, metadataBlocks As ImmutableArray(Of MetadataBlock), - moduleVersionId As Guid, + moduleId As ModuleId, typeToken As Integer, kind As MakeAssemblyReferencesKind) As EvaluationContext @@ -171,7 +171,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests appDomain, Function(ad) ad.GetMetadataContext(), metadataBlocks, - moduleVersionId, + moduleId, typeToken, kind) End Function @@ -181,7 +181,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests metadataBlocks As ImmutableArray(Of MetadataBlock), lazyAssemblyReaders As Lazy(Of ImmutableArray(Of AssemblyReaders)), symReader As Object, - moduleVersionId As Guid, + moduleId As ModuleId, methodToken As Integer, methodVersion As Integer, ilOffset As UInteger, @@ -195,7 +195,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests metadataBlocks, lazyAssemblyReaders, symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -206,14 +206,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests Friend Shared Function CreateMethodContext( appDomain As AppDomain, blocks As ImmutableArray(Of MetadataBlock), - state As (ModuleVersionId As Guid, SymReader As ISymUnmanagedReader, MethodToken As Integer, LocalSignatureToken As Integer, ILOffset As UInteger)) As EvaluationContext + state As (ModuleId As ModuleId, SymReader As ISymUnmanagedReader, MethodToken As Integer, LocalSignatureToken As Integer, ILOffset As UInteger)) As EvaluationContext Return CreateMethodContext( appDomain, blocks, MakeDummyLazyAssemblyReaders(), state.SymReader, - state.ModuleVersionId, + state.ModuleId, state.MethodToken, methodVersion:=1, state.ILOffset, @@ -221,13 +221,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests MakeAssemblyReferencesKind.AllReferences) End Function - Friend Shared Function GetMetadataContext(appDomainContext As MetadataContext(Of VisualBasicMetadataContext), Optional mvid As Guid = Nothing) As VisualBasicMetadataContext + Friend Shared Function GetMetadataContext(appDomainContext As MetadataContext(Of VisualBasicMetadataContext), Optional moduleId As ModuleId = Nothing) As VisualBasicMetadataContext Dim assemblyContexts = appDomainContext.AssemblyContexts If assemblyContexts Is Nothing Then Return Nothing End If Dim context As VisualBasicMetadataContext = Nothing - assemblyContexts.TryGetValue(New MetadataContextId(mvid), context) + assemblyContexts.TryGetValue(New MetadataContextId(moduleId.Id), context) Return context End Function @@ -244,11 +244,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests Optional lazyAssemblyReaders As Lazy(Of ImmutableArray(Of AssemblyReaders)) = Nothing) As EvaluationContext Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, methodName, blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, methodName, blocks, moduleId, symReader, methodToken, localSignatureToken) Const methodVersion = 1 Dim ilOffset = ExpressionCompilerTestHelpers.GetOffset(methodToken, symReader, atLineNumber) @@ -258,7 +258,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests blocks, If(lazyAssemblyReaders, MakeDummyLazyAssemblyReaders()), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -280,16 +280,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests typeName As String) As EvaluationContext Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim typeToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, typeName, blocks, moduleVersionId, symReader, typeToken, localSignatureToken) + GetContextState(runtime, typeName, blocks, moduleId, symReader, typeToken, localSignatureToken) Return VisualBasicExpressionCompiler.CreateTypeContextHelper( New AppDomain(), Function(ad) ad.GetMetadataContext(), blocks, - moduleVersionId, + moduleId, typeToken, MakeAssemblyReferencesKind.AllAssemblies) End Function @@ -465,7 +465,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.UnitTests Dim peCompilation = runtime.Modules.SelectAsArray(Function(m) m.MetadataBlock).ToCompilation() Dim peMethod = peCompilation.GlobalNamespace.GetMember(Of PEMethodSymbol)(qualifiedMethodName) Dim peModule = DirectCast(peMethod.ContainingModule, PEModuleSymbol) - Dim symReader = runtime.Modules.Single(Function(mi) mi.ModuleVersionId = peModule.Module.GetModuleVersionIdOrThrow()).SymReader + Dim symReader = runtime.Modules.Single(Function(mi) mi.Id.Id = peModule.Module.GetModuleVersionIdOrThrow()).SymReader Dim symbolProvider = New VisualBasicEESymbolProvider(peModule, peMethod) Return MethodDebugInfo(Of TypeSymbol, LocalSymbol).ReadMethodDebugInfo(DirectCast(symReader, ISymUnmanagedReader3), symbolProvider, MetadataTokens.GetToken(peMethod.Handle), methodVersion:=1, ilOffset:=ilOffset, isVisualBasicMethod:=True) End Function diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTests.vb index fdc9a9d470428..568aa79b5bdc4 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ExpressionCompilerTests.vb @@ -42,11 +42,11 @@ End Class Sub(runtime) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C.M", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.M", blocks, moduleId, symReader, methodToken, localSignatureToken) Const methodVersion = 1 Dim appDomain = New AppDomain() @@ -56,7 +56,7 @@ End Class blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -74,7 +74,7 @@ End Class blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -317,13 +317,13 @@ End Class" Dim typeBlocks As ImmutableArray(Of MetadataBlock) = Nothing Dim methodBlocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim typeToken = 0 Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C", typeBlocks, moduleVersionId, symReader, typeToken, localSignatureToken) - GetContextState(runtime, "C.F", methodBlocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C", typeBlocks, moduleId, symReader, typeToken, localSignatureToken) + GetContextState(runtime, "C.F", methodBlocks, moduleId, symReader, methodToken, localSignatureToken) ' Get non-empty scopes. Dim scopes = symReader.GetScopes(methodToken, methodVersion, isEndInclusive:=True).WhereAsArray(Function(s) s.Locals.Length > 0) @@ -334,15 +334,15 @@ End Class" endOffset = outerScope.EndOffset ' At start of outer scope. - Dim context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion, CType(startOffset, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) + Dim context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion, CType(startOffset, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) ' At end of outer scope - not reused because of the nested scope. Dim previous = appDomain.GetMetadataContext() - context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion, CType(endOffset, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) + context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion, CType(endOffset, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext) ' Not required, just documentary. ' At type context. - context = CreateTypeContext(appDomain, typeBlocks, moduleVersionId, typeToken, MakeAssemblyReferencesKind.AllAssemblies) + context = CreateTypeContext(appDomain, typeBlocks, moduleId, typeToken, MakeAssemblyReferencesKind.AllAssemblies) Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext) Assert.Null(context.MethodContextReuseConstraints) Assert.Equal(context.Compilation, GetMetadataContext(previous).Compilation) @@ -354,10 +354,10 @@ End Class" Dim scope = scopes.GetInnermostScope(offset) Dim constraints = GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints If constraints.HasValue Then - Assert.Equal(scope Is previousScope, constraints.GetValueOrDefault().AreSatisfied(moduleVersionId, methodToken, methodVersion, offset)) + Assert.Equal(scope Is previousScope, constraints.GetValueOrDefault().AreSatisfied(moduleId, methodToken, methodVersion, offset)) End If - context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion, CType(offset, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) + context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion, CType(offset, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) If scope Is previousScope Then Assert.Equal(context, GetMetadataContext(previous).EvaluationContext) Else @@ -376,24 +376,24 @@ End Class" Dim fewerReferences = {MscorlibRef} runtime = CreateRuntimeInstance(moduleB, fewerReferences) methodBlocks = Nothing - moduleVersionId = Nothing + moduleId = Nothing symReader = Nothing methodToken = 0 localSignatureToken = 0 - GetContextState(runtime, "C.F", methodBlocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.F", methodBlocks, moduleId, symReader, methodToken, localSignatureToken) ' Different references. No reuse. - context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion, CType(endOffset - 1, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) + context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion, CType(endOffset - 1, UInteger), localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext) - Assert.True(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleVersionId, methodToken, methodVersion, endOffset - 1)) + Assert.True(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleId, methodToken, methodVersion, endOffset - 1)) Assert.NotEqual(context.Compilation, GetMetadataContext(previous).Compilation) previous = appDomain.GetMetadataContext() ' Different method. Should reuse Compilation. - GetContextState(runtime, "C.G", methodBlocks, moduleVersionId, symReader, methodToken, localSignatureToken) - context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion, ilOffset:=0, localSignatureToken:=localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) + GetContextState(runtime, "C.G", methodBlocks, moduleId, symReader, methodToken, localSignatureToken) + context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion, ilOffset:=0, localSignatureToken:=localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) Assert.NotEqual(context, GetMetadataContext(previous).EvaluationContext) - Assert.False(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleVersionId, methodToken, methodVersion, 0)) + Assert.False(GetMetadataContext(previous).EvaluationContext.MethodContextReuseConstraints.Value.AreSatisfied(moduleId, methodToken, methodVersion, 0)) Assert.Equal(context.Compilation, GetMetadataContext(previous).Compilation) ' No EvaluationContext. Should reuse Compilation @@ -401,7 +401,7 @@ End Class" previous = appDomain.GetMetadataContext() Assert.Null(GetMetadataContext(previous).EvaluationContext) Assert.NotNull(GetMetadataContext(previous).Compilation) - context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion, ilOffset:=0, localSignatureToken:=localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) + context = CreateMethodContext(appDomain, methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion, ilOffset:=0, localSignatureToken:=localSignatureToken, MakeAssemblyReferencesKind.AllAssemblies) Assert.Null(GetMetadataContext(previous).EvaluationContext) Assert.NotNull(context) Assert.Equal(context.Compilation, GetMetadataContext(previous).Compilation) @@ -3690,7 +3690,7 @@ End Class" Dim comp = CreateCompilationWithMscorlib40({source}, options:=TestOptions.DebugDll, assemblyName:=GetUniqueName()) Using pinnedMetadata = New PinnedBlob(TestResources.ExpressionCompiler.NoValidTables) - Dim corruptMetadata = ModuleInstance.Create(pinnedMetadata.Pointer, pinnedMetadata.Size, moduleVersionId:=Nothing) + Dim corruptMetadata = ModuleInstance.Create(pinnedMetadata.Pointer, pinnedMetadata.Size, id:=Nothing) Dim runtime = CreateRuntimeInstance({corruptMetadata, comp.ToModuleInstance(), MscorlibRef.ToModuleInstance()}) Dim context = CreateMethodContext(runtime, "C.M") @@ -4126,11 +4126,11 @@ End Class Dim runtime = CreateRuntimeInstance(module2, {MscorlibRef, ExpressionCompilerTestHelpers.IntrinsicAssemblyReference}) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader2 As ISymUnmanagedReader = Nothing Dim methodToken As Integer = Nothing Dim localSignatureToken As Integer = Nothing - GetContextState(runtime, "C.M", blocks, moduleVersionId, symReader2, methodToken, localSignatureToken) + GetContextState(runtime, "C.M", blocks, moduleId, symReader2, methodToken, localSignatureToken) Assert.Same(symReader, symReader2) @@ -4142,7 +4142,7 @@ End Class blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken:=methodToken, methodVersion:=1, ilOffset:=0, @@ -4163,7 +4163,7 @@ End Class blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken:=methodToken, methodVersion:=2, ilOffset:=0, @@ -4538,11 +4538,11 @@ End Class" Sub(runtime) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C.M", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.M", blocks, moduleId, symReader, methodToken, localSignatureToken) Dim appDomain = New AppDomain() Dim context = CreateMethodContext( @@ -4550,7 +4550,7 @@ End Class" blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=ExpressionCompilerTestHelpers.NoILOffset, @@ -4578,7 +4578,7 @@ End Class" blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, @@ -4593,7 +4593,7 @@ End Class" blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=ExpressionCompilerTestHelpers.NoILOffset, diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/HoistedStateMachineLocalTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/HoistedStateMachineLocalTests.vb index 218e9771e51ac..6a59f8947a0e2 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/HoistedStateMachineLocalTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/HoistedStateMachineLocalTests.vb @@ -1419,11 +1419,11 @@ End Class WithRuntimeInstance(comp, Sub(runtime) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C.VB$StateMachine_1_M.MoveNext", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.VB$StateMachine_1_M.MoveNext", blocks, moduleId, symReader, methodToken, localSignatureToken) Const methodVersion = 1 Dim appDomain = New AppDomain() @@ -1433,7 +1433,7 @@ End Class blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, @@ -1452,7 +1452,7 @@ End Class blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion, ilOffset, diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb index 97f7db63389c2..e23059f839fb2 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb @@ -653,7 +653,7 @@ End Class" ' using the same helper as the product code. This helper will also map ' async/ iterator "MoveNext" methods to the original source method. Dim method As MethodSymbol = compilation.GetSourceMethod( - DirectCast(frame.ContainingModule, PEModuleSymbol).Module.GetModuleVersionIdOrThrow(), + New ModuleId(DirectCast(frame.ContainingModule, PEModuleSymbol).Module.GetModuleVersionIdOrThrow(), frame.ContainingModule.Name), frame.Handle) If serializedTypeArgumentNames IsNot Nothing Then Assert.NotEmpty(serializedTypeArgumentNames) diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb index b3bbf6b46a89f..8ed7524cf3bbc 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb @@ -3382,10 +3382,10 @@ End Class" Private Shared Sub GetLocals(runtime As RuntimeInstance, methodName As String, debugInfo As MethodDebugInfoBytes, locals As ArrayBuilder(Of LocalAndMethod), count As Integer) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, methodName, blocks, moduleVersionId, symReader:=Nothing, methodOrTypeToken:=methodToken, localSignatureToken:=localSignatureToken) + GetContextState(runtime, methodName, blocks, moduleId, symReader:=Nothing, methodOrTypeToken:=methodToken, localSignatureToken:=localSignatureToken) Dim symReader = New MockSymUnmanagedReader( New Dictionary(Of Integer, MethodDebugInfoBytes)() From @@ -3397,7 +3397,7 @@ End Class" blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.UnitTests.vbproj b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.UnitTests.vbproj index 09fc271070543..1b91ac618bbb1 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.UnitTests.vbproj +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.UnitTests.vbproj @@ -16,7 +16,7 @@ - + diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/MissingAssemblyTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/MissingAssemblyTests.vb index 9a76d1d8ab6c1..5b6bd8eeb95f3 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/MissingAssemblyTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/MissingAssemblyTests.vb @@ -521,6 +521,7 @@ End Class Dim numRetries = 0 Dim errorMessage As String = Nothing + Dim compileResult As CompileResult = Nothing ExpressionCompilerTestHelpers.CompileExpressionWithRetry( runtime.Modules.Select(Function(m) m.MetadataBlock).ToImmutableArray(), context, @@ -534,6 +535,7 @@ End Class uSize = CUInt(missingModule.MetadataLength) Return missingModule.MetadataAddress End Function, + compileResult, errorMessage) Assert.Equal(2, numRetries) ' Ensure that we actually retried and that we bailed out on the second retry if the same identity was seen in the diagnostics. @@ -675,12 +677,12 @@ End Class" WithRuntimeInstance(comp, {Net461.References.mscorlib, ValueTupleLegacyRef}, Sub(runtime) Dim methodBlocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim typeToken = 0 Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C.M", methodBlocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.M", methodBlocks, moduleId, symReader, methodToken, localSignatureToken) Dim errorMessage As String = Nothing Dim testData As CompilationTestData = Nothing Dim retryCount = 0 @@ -688,7 +690,7 @@ End Class" runtime.Modules.Select(Function(m) m.MetadataBlock).ToImmutableArray(), expression, ImmutableArray(Of [Alias]).Empty, - Function(b, u) EvaluationContext.CreateMethodContext(b.ToCompilation(), MakeDummyLazyAssemblyReaders(), symReader, moduleVersionId, methodToken, methodVersion:=1, ilOffset:=0, localSignatureToken:=localSignatureToken), + Function(b, u) EvaluationContext.CreateMethodContext(b.ToCompilation(), MakeDummyLazyAssemblyReaders(), symReader, moduleId, methodToken, methodVersion:=1, ilOffset:=0, localSignatureToken:=localSignatureToken), Function(assemblyIdentity As AssemblyIdentity, ByRef uSize As UInteger) retryCount += 1 Assert.Equal("System.Runtime", assemblyIdentity.Name) diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb index 73177efc24708..035e5a7d149dc 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb @@ -191,7 +191,7 @@ End Class" allBlocks, MakeDummyLazyAssemblyReaders(), stateA1.SymReader, - stateA1.ModuleVersionId, + stateA1.ModuleId, stateA1.MethodToken, methodVersion:=1, stateA1.ILOffset, @@ -213,7 +213,7 @@ End Class" allBlocks, MakeDummyLazyAssemblyReaders(), stateA1.SymReader, - stateA1.ModuleVersionId, + stateA1.ModuleId, stateA1.MethodToken, methodVersion:=1, UInteger.MaxValue, @@ -275,9 +275,9 @@ End Class" Dim stateB1 = GetContextState(runtime, "B1.M") Dim stateB2 = GetContextState(runtime, "B2.M") - Dim mvidA1 = stateA1.ModuleVersionId - Dim mvidA2 = stateA2.ModuleVersionId - Dim mvidB1 = stateB1.ModuleVersionId + Dim mvidA1 = stateA1.ModuleId + Dim mvidA2 = stateA2.ModuleId + Dim mvidB1 = stateB1.ModuleId Dim context As EvaluationContext Dim previous As MetadataContext(Of VisualBasicMetadataContext) @@ -357,8 +357,8 @@ End Class" End Using End Sub - Private Shared Sub VerifyAppDomainMetadataContext(appDomain As AppDomain, ParamArray moduleVersionIds As Guid()) - ExpressionCompilerTestHelpers.VerifyAppDomainMetadataContext(appDomain.GetMetadataContext(), moduleVersionIds) + Private Shared Sub VerifyAppDomainMetadataContext(appDomain As AppDomain, ParamArray moduleIds As ModuleId()) + ExpressionCompilerTestHelpers.VerifyAppDomainMetadataContext(appDomain.GetMetadataContext(), moduleIds) End Sub @@ -424,20 +424,20 @@ End Class" Sub(runtime) Dim typeBlocks As ImmutableArray(Of MetadataBlock) = Nothing Dim methodBlocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim typeToken = 0 Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C", typeBlocks, moduleVersionId, symReader, typeToken, localSignatureToken) - GetContextState(runtime, "C.M", methodBlocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C", typeBlocks, moduleId, symReader, typeToken, localSignatureToken) + GetContextState(runtime, "C.M", methodBlocks, moduleId, symReader, methodToken, localSignatureToken) ' Compile expression with type context. Dim appDomain = New AppDomain() Dim context = CreateTypeContext( appDomain, typeBlocks, - moduleVersionId, + moduleId, typeToken, MakeAssemblyReferencesKind.AllAssemblies) @@ -464,7 +464,7 @@ End Class" methodBlocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, @@ -561,13 +561,13 @@ End Class" }) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim typeToken = 0 Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "B", blocks, moduleVersionId, symReader, typeToken, localSignatureToken) - Dim contextFactory = CreateTypeContextFactory(moduleVersionId, typeToken) + GetContextState(runtime, "B", blocks, moduleId, symReader, typeToken, localSignatureToken) + Dim contextFactory = CreateTypeContextFactory(moduleId, typeToken) ' Duplicate type in namespace, at type scope. Dim testData As CompilationTestData = Nothing @@ -575,8 +575,8 @@ End Class" ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "New N.C1()", ImmutableArray(Of [Alias]).Empty, contextFactory, getMetaDataBytesPtr:=Nothing, errorMessage:=errorMessage, testData:=testData) Assert.Equal($"error BC30560: { String.Format(VBResources.ERR_AmbiguousInNamespace2, "C1", "N") }", errorMessage) - GetContextState(runtime, "B.Main", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) - contextFactory = CreateMethodContextFactory(moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "B.Main", blocks, moduleId, symReader, methodToken, localSignatureToken) + contextFactory = CreateMethodContextFactory(moduleId, symReader, methodToken, localSignatureToken) ' Duplicate type in namespace, at method scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "New C1()", ImmutableArray(Of [Alias]).Empty, contextFactory, getMetaDataBytesPtr:=Nothing, errorMessage:=errorMessage, testData:=testData) @@ -591,8 +591,8 @@ End Class" Assert.True(errorMessage.StartsWith($"error BC30521: { String.Format(VBResources.ERR_NoMostSpecificOverload2, "F", "") }")) ' Same tests as above but in library that does not directly reference duplicates. - GetContextState(runtime, "A", blocks, moduleVersionId, symReader, typeToken, localSignatureToken) - contextFactory = CreateTypeContextFactory(moduleVersionId, typeToken) + GetContextState(runtime, "A", blocks, moduleId, symReader, typeToken, localSignatureToken) + contextFactory = CreateTypeContextFactory(moduleId, typeToken) ' Duplicate type in namespace, at type scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "New N.C1()", ImmutableArray(Of [Alias]).Empty, contextFactory, getMetaDataBytesPtr:=Nothing, errorMessage:=errorMessage, testData:=testData) @@ -607,8 +607,8 @@ IL_0005: ret }") Assert.Equal(methodData.Method.ReturnType.ContainingAssembly.ToDisplayString(), identityA.GetDisplayName()) - GetContextState(runtime, "A.M", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) - contextFactory = CreateMethodContextFactory(moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "A.M", blocks, moduleId, symReader, methodToken, localSignatureToken) + contextFactory = CreateMethodContextFactory(moduleId, symReader, methodToken, localSignatureToken) ' Duplicate type in global namespace, at method scope. ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "New C2()", ImmutableArray(Of [Alias]).Empty, contextFactory, getMetaDataBytesPtr:=Nothing, errorMessage:=errorMessage, testData:=testData) @@ -681,19 +681,19 @@ End Class" Sub(runtime) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim typeToken = 0 Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C.M", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.M", blocks, moduleId, symReader, methodToken, localSignatureToken) Dim context = CreateMethodContext( New AppDomain(), blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, @@ -704,7 +704,7 @@ End Class" Assert.Equal(errorMessage, "error BC30562: 'F' is ambiguous between declarations in Modules 'N.M, N.M'.") Dim testData As New CompilationTestData() - Dim contextFactory = CreateMethodContextFactory(moduleVersionId, symReader, methodToken, localSignatureToken) + Dim contextFactory = CreateMethodContextFactory(moduleId, symReader, methodToken, localSignatureToken) ExpressionCompilerTestHelpers.CompileExpressionWithRetry(blocks, "F()", ImmutableArray(Of [Alias]).Empty, contextFactory, getMetaDataBytesPtr:=Nothing, errorMessage:=errorMessage, testData:=testData) Assert.Null(errorMessage) testData.GetMethodData("<>x.<>m0").VerifyIL( @@ -852,7 +852,7 @@ End Namespace" Dim metadata = reader.GetMetadata() Dim [module] = metadata.ToModuleMetadata(ignoreAssemblyRefs:=True) Dim metadataReader = metadata.ToMetadataReader() - Dim moduleInstance = Microsoft.CodeAnalysis.ExpressionEvaluator.UnitTests.ModuleInstance.Create(metadata, metadataReader.GetModuleVersionIdOrThrow()) + Dim moduleInstance = Microsoft.CodeAnalysis.ExpressionEvaluator.UnitTests.ModuleInstance.Create(metadata, New ModuleId(metadataReader.GetModuleVersionIdOrThrow(), [module].Name)) ' Verify the module declares System.Object. Assert.True(metadataReader.DeclaresTheObjectClass()) @@ -909,31 +909,31 @@ End Class" End Sub Private Shared Function CreateTypeContextFactory( - moduleVersionId As Guid, + moduleId As ModuleId, typeToken As Integer) As ExpressionCompiler.CreateContextDelegate Return Function(blocks, useReferencedModulesOnly) - Dim compilation = If(useReferencedModulesOnly, blocks.ToCompilationReferencedModulesOnly(moduleVersionId), blocks.ToCompilation()) + Dim compilation = If(useReferencedModulesOnly, blocks.ToCompilationReferencedModulesOnly(moduleId), blocks.ToCompilation()) Return EvaluationContext.CreateTypeContext( compilation, - moduleVersionId, + moduleId, typeToken) End Function End Function Private Shared Function CreateMethodContextFactory( - moduleVersionId As Guid, + moduleId As ModuleId, symReader As ISymUnmanagedReader, methodToken As Integer, localSignatureToken As Integer) As ExpressionCompiler.CreateContextDelegate Return Function(blocks, useReferencedModulesOnly) - Dim compilation = If(useReferencedModulesOnly, blocks.ToCompilationReferencedModulesOnly(moduleVersionId), blocks.ToCompilation()) + Dim compilation = If(useReferencedModulesOnly, blocks.ToCompilationReferencedModulesOnly(moduleId), blocks.ToCompilation()) Return EvaluationContext.CreateMethodContext( compilation, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/StaticLocalsTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/StaticLocalsTests.vb index 97a688fcf41da..24bbc046eb7e8 100644 --- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/StaticLocalsTests.vb +++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/StaticLocalsTests.vb @@ -186,17 +186,17 @@ End Class" WithRuntimeInstance(comp, Sub(runtime) Dim blocks As ImmutableArray(Of MetadataBlock) = Nothing - Dim moduleVersionId As Guid = Nothing + Dim moduleId As ModuleId = Nothing Dim symReader As ISymUnmanagedReader = Nothing Dim methodToken = 0 Dim localSignatureToken = 0 - GetContextState(runtime, "C.F(Boolean)", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.F(Boolean)", blocks, moduleId, symReader, methodToken, localSignatureToken) Dim context = CreateMethodContext( New AppDomain(), blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, @@ -233,13 +233,13 @@ End Class" }") locals.Free() - GetContextState(runtime, "C.F(Int32)", blocks, moduleVersionId, symReader, methodToken, localSignatureToken) + GetContextState(runtime, "C.F(Int32)", blocks, moduleId, symReader, methodToken, localSignatureToken) context = CreateMethodContext( New AppDomain(), blocks, MakeDummyLazyAssemblyReaders(), symReader, - moduleVersionId, + moduleId, methodToken, methodVersion:=1, ilOffset:=0, From 6f29e131605164509e58d32d1579e55842303b0b Mon Sep 17 00:00:00 2001 From: Ankita Khera <40616383+akhera99@users.noreply.github.com> Date: Thu, 23 Jan 2025 13:39:12 -0800 Subject: [PATCH 38/76] On-the-fly-docs -- Add quota exceeded dialogue (#76877) * wip * wip * revert * comments * pr feedback * pr feedback * pr feedback --- .../QuickInfo/OnTheFlyDocsView.xaml.cs | 103 ++++++++++++++++-- .../QuickInfo/OnTheFlyDocsViewFactory.cs | 8 +- .../Core/EditorFeaturesResources.resx | 4 + .../Core/xlf/EditorFeaturesResources.cs.xlf | 5 + .../Core/xlf/EditorFeaturesResources.de.xlf | 5 + .../Core/xlf/EditorFeaturesResources.es.xlf | 5 + .../Core/xlf/EditorFeaturesResources.fr.xlf | 5 + .../Core/xlf/EditorFeaturesResources.it.xlf | 5 + .../Core/xlf/EditorFeaturesResources.ja.xlf | 5 + .../Core/xlf/EditorFeaturesResources.ko.xlf | 5 + .../Core/xlf/EditorFeaturesResources.pl.xlf | 5 + .../xlf/EditorFeaturesResources.pt-BR.xlf | 5 + .../Core/xlf/EditorFeaturesResources.ru.xlf | 5 + .../Core/xlf/EditorFeaturesResources.tr.xlf | 5 + .../xlf/EditorFeaturesResources.zh-Hans.xlf | 5 + .../xlf/EditorFeaturesResources.zh-Hant.xlf | 5 + ...xternalCSharpCopilotCodeAnalysisService.cs | 2 +- .../AbstractCopilotCodeAnalysisService.cs | 6 +- ...otCodeAnalysisService.ReflectionWrapper.cs | 6 +- .../CSharpCopilotCodeAnalysisService.cs | 2 +- .../Copilot/InternalAPI.Unshipped.txt | 2 +- .../Test2/CodeFixes/CodeFixServiceTests.vb | 4 +- .../Copilot/ICopilotCodeAnalysisService.cs | 2 +- 23 files changed, 180 insertions(+), 24 deletions(-) diff --git a/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsView.xaml.cs b/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsView.xaml.cs index f2ab905041903..424d1c8c775d2 100644 --- a/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsView.xaml.cs +++ b/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsView.xaml.cs @@ -3,8 +3,11 @@ // See the LICENSE file in the project root for more information. using System; +using System.Collections.Generic; using System.ComponentModel; +using System.Diagnostics; using System.Runtime.CompilerServices; +using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; using System.Windows; @@ -20,6 +23,9 @@ using Microsoft.CodeAnalysis.Shared.TestHooks; using Microsoft.VisualStudio.Language.Intellisense; using Microsoft.VisualStudio.PlatformUI; +using Microsoft.VisualStudio.Shell; +using Microsoft.VisualStudio.Shell.Interop; +using Microsoft.VisualStudio.Telemetry; using Microsoft.VisualStudio.Text.Adornments; using Microsoft.VisualStudio.Text.Editor; using Roslyn.Utilities; @@ -40,6 +46,8 @@ internal sealed partial class OnTheFlyDocsView : UserControl, INotifyPropertyCha private readonly OnTheFlyDocsInfo _onTheFlyDocsInfo; private readonly ContentControl _responseControl = new(); private readonly CancellationTokenSource _cancellationTokenSource = new(); + private readonly List quotaExceededContent; + private readonly IServiceProvider _serviceProvider; private OnTheFlyDocsState _currentState = OnTheFlyDocsState.OnDemandLink; @@ -51,6 +59,11 @@ internal sealed partial class OnTheFlyDocsView : UserControl, INotifyPropertyCha /// public event EventHandler ResultsRequested; + /// + /// Event that fires when the user requests to upgrade their Copilot plan. + /// + public event EventHandler? PlanUpgradeRequested; + #pragma warning disable CA1822 // Mark members as static /// /// Used to display the "On the fly documentation" directly in the associated XAML file. @@ -58,7 +71,9 @@ internal sealed partial class OnTheFlyDocsView : UserControl, INotifyPropertyCha public string OnTheFlyDocumentation => EditorFeaturesResources.On_the_fly_documentation; #pragma warning restore CA1822 // Mark members as static - public OnTheFlyDocsView(ITextView textView, IViewElementFactoryService viewElementFactoryService, IAsynchronousOperationListenerProvider listenerProvider, IAsyncQuickInfoSession asyncQuickInfoSession, IThreadingContext threadingContext, QuickInfoOnTheFlyDocsElement onTheFlyDocsElement) + public OnTheFlyDocsView(ITextView textView, IViewElementFactoryService viewElementFactoryService, + IAsynchronousOperationListenerProvider listenerProvider, IAsyncQuickInfoSession asyncQuickInfoSession, + IThreadingContext threadingContext, QuickInfoOnTheFlyDocsElement onTheFlyDocsElement, IServiceProvider serviceProvider) { _textView = textView; _viewElementFactoryService = viewElementFactoryService; @@ -67,6 +82,7 @@ public OnTheFlyDocsView(ITextView textView, IViewElementFactoryService viewEleme _threadingContext = threadingContext; _onTheFlyDocsInfo = onTheFlyDocsElement.Info; _document = onTheFlyDocsElement.Document; + _serviceProvider = serviceProvider; var sparkle = new ImageElement(new VisualStudio.Core.Imaging.ImageId(CopilotConstants.CopilotIconMonikerGuid, CopilotConstants.CopilotIconSparkleId)); object onDemandLinkText = _onTheFlyDocsInfo.IsContentExcluded @@ -111,6 +127,34 @@ public OnTheFlyDocsView(ITextView textView, IViewElementFactoryService viewEleme _responseControl, ])); + // Locates the "upgrade now" link in the localized text, surrounded by square brackets. + var quotaExceededMatch = Regex.Match( + EditorFeaturesResources.Chat_limit_reached_upgrade_now_or_wait_for_the_limit_to_reset, + @"^(.*)\[(.*)\](.*)$"); + if (quotaExceededMatch == null) + { + // The text wasn't localized correctly. Assert and fallback to showing it verbatim. + Debug.Fail("Copilot Hover quota exceeded message was not correctly localized."); + quotaExceededContent = [new ClassifiedTextRun( + ClassifiedTextElement.TextClassificationTypeName, + EditorFeaturesResources.Chat_limit_reached_upgrade_now_or_wait_for_the_limit_to_reset)]; + } + else + { + quotaExceededContent = [ + new ClassifiedTextRun( + ClassifiedTextElement.TextClassificationTypeName, + quotaExceededMatch.Groups[1].Value), + new ClassifiedTextRun( + ClassifiedTextElement.TextClassificationTypeName, + quotaExceededMatch.Groups[2].Value, + () => this.PlanUpgradeRequested?.Invoke(this, EventArgs.Empty)), + new ClassifiedTextRun( + ClassifiedTextElement.TextClassificationTypeName, + quotaExceededMatch.Groups[3].Value), + ]; + } + ResultsRequested += (_, _) => PopulateAIDocumentationElements(_cancellationTokenSource.Token); _asyncQuickInfoSession.StateChanged += (_, _) => OnQuickInfoSessionChanged(); InitializeComponent(); @@ -135,31 +179,61 @@ private async Task SetResultTextAsync(ICopilotCodeAnalysisService copilotService try { - var response = await copilotService.GetOnTheFlyDocsAsync(_onTheFlyDocsInfo.SymbolSignature, _onTheFlyDocsInfo.DeclarationCode, _onTheFlyDocsInfo.Language, cancellationToken).ConfigureAwait(false); + var (responseString, isQuotaExceeded) = await copilotService.GetOnTheFlyDocsAsync(_onTheFlyDocsInfo.SymbolSignature, _onTheFlyDocsInfo.DeclarationCode, _onTheFlyDocsInfo.Language, cancellationToken).ConfigureAwait(false); var copilotRequestTime = stopwatch.Elapsed; await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); cancellationToken.ThrowIfCancellationRequested(); - if (response is null || response.Length == 0) + if (string.IsNullOrEmpty(responseString)) { - SetResultText(EditorFeaturesResources.An_error_occurred_while_generating_documentation_for_this_code); - CurrentState = OnTheFlyDocsState.Finished; - Logger.Log(FunctionId.Copilot_On_The_Fly_Docs_Error_Displayed, KeyValueLogMessage.Create(m => + // If the responseStatus is 8, then that means the quota has been exceeded. + if (isQuotaExceeded) { - m["ElapsedTime"] = copilotRequestTime; - }, LogLevel.Information)); + this.PlanUpgradeRequested += (_, _) => + { + // GUID and command ID from + // https://dev.azure.com/devdiv/DevDiv/_wiki/wikis/DevDiv.wiki/45121/Free-SKU-Handling-Guidance-and-Recommendations + var uiShell = _serviceProvider.GetServiceOnMainThread(); + uiShell.PostExecCommand( + new Guid("39B0DEDE-D931-4A92-9AA2-3447BC4998DC"), + 0x3901, + nCmdexecopt: 0, + pvaIn: null); + + _asyncQuickInfoSession.DismissAsync(); + + // Telemetry to track when users reach the quota of the Copilot Free plan. + var telemetryEvent = new OperationEvent( + "vs/copilot/showcopilotfreestatus", + TelemetryResult.Success); + telemetryEvent.Properties["vs.copilot.source"] = "CSharpOnTheFlyDocs"; + TelemetryService.DefaultSession.PostEvent(telemetryEvent); + }; + + ShowQuotaExceededResult(); + } + else + { + SetResultText(EditorFeaturesResources.An_error_occurred_while_generating_documentation_for_this_code); + Logger.Log(FunctionId.Copilot_On_The_Fly_Docs_Error_Displayed, KeyValueLogMessage.Create(m => + { + m["ElapsedTime"] = copilotRequestTime; + }, LogLevel.Information)); + } + + CurrentState = OnTheFlyDocsState.Finished; } else { - SetResultText(response); + SetResultText(responseString); CurrentState = OnTheFlyDocsState.Finished; Logger.Log(FunctionId.Copilot_On_The_Fly_Docs_Results_Displayed, KeyValueLogMessage.Create(m => { m["ElapsedTime"] = copilotRequestTime; - m["ResponseLength"] = response.Length; + m["ResponseLength"] = responseString.Length; }, LogLevel.Information)); } } @@ -222,6 +296,15 @@ public void SetResultText(string text) new ContainerElement(ContainerElementStyle.Wrapped, new ClassifiedTextElement([new ClassifiedTextRun(ClassificationTypeNames.Text, text)]))); } + /// + /// Shows a result message for exceeding the quota of the Copilot Free plan. + /// + public void ShowQuotaExceededResult() + { + _responseControl.Content = ToUIElement(new ContainerElement(ContainerElementStyle.Stacked, + [new ContainerElement(ContainerElementStyle.Wrapped, new ClassifiedTextElement(this.quotaExceededContent))])); + } + private void OnPropertyChanged(ref T member, T value, [CallerMemberName] string? name = null) { member = value; diff --git a/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsViewFactory.cs b/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsViewFactory.cs index 35ee7beb5349d..c0b96f3cf63ea 100644 --- a/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsViewFactory.cs +++ b/src/EditorFeatures/Core.Wpf/QuickInfo/OnTheFlyDocsViewFactory.cs @@ -12,6 +12,7 @@ using Microsoft.CodeAnalysis.QuickInfo.Presentation; using Microsoft.CodeAnalysis.Shared.TestHooks; using Microsoft.VisualStudio.Language.Intellisense; +using Microsoft.VisualStudio.Shell; using Microsoft.VisualStudio.Text.Adornments; using Microsoft.VisualStudio.Text.Editor; using Microsoft.VisualStudio.Utilities; @@ -28,15 +29,18 @@ internal sealed class OnTheFlyDocsViewFactory : IViewElementFactory private readonly IAsynchronousOperationListenerProvider _listenerProvider; private readonly IAsyncQuickInfoBroker _asyncQuickInfoBroker; private readonly IThreadingContext _threadingContext; + private readonly IServiceProvider _serviceProvider; [ImportingConstructor] [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public OnTheFlyDocsViewFactory(IViewElementFactoryService factoryService, IAsynchronousOperationListenerProvider listenerProvider, IAsyncQuickInfoBroker asyncQuickInfoBroker, IThreadingContext threadingContext) + public OnTheFlyDocsViewFactory(IViewElementFactoryService factoryService, IAsynchronousOperationListenerProvider listenerProvider, + IAsyncQuickInfoBroker asyncQuickInfoBroker, IThreadingContext threadingContext, SVsServiceProvider serviceProvider) { _factoryService = factoryService; _listenerProvider = listenerProvider; _asyncQuickInfoBroker = asyncQuickInfoBroker; _threadingContext = threadingContext; + _serviceProvider = serviceProvider; } public TView? CreateViewElement(ITextView textView, object model) where TView : class @@ -64,6 +68,6 @@ public OnTheFlyDocsViewFactory(IViewElementFactoryService factoryService, IAsync OnTheFlyDocsLogger.LogShowedOnTheFlyDocsLinkWithDocComments(); } - return new OnTheFlyDocsView(textView, _factoryService, _listenerProvider, quickInfoSession, _threadingContext, onTheFlyDocsElement) as TView; + return new OnTheFlyDocsView(textView, _factoryService, _listenerProvider, quickInfoSession, _threadingContext, onTheFlyDocsElement, _serviceProvider) as TView; } } diff --git a/src/EditorFeatures/Core/EditorFeaturesResources.resx b/src/EditorFeatures/Core/EditorFeaturesResources.resx index 0d2ddf466abbc..42d5a9f806b9d 100644 --- a/src/EditorFeatures/Core/EditorFeaturesResources.resx +++ b/src/EditorFeatures/Core/EditorFeaturesResources.resx @@ -950,4 +950,8 @@ Do you want to proceed? 'Describe with Copilot' is unavailable since the referenced document is excluded by your organization. + + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + \ No newline at end of file diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf index deadfb68a2575..cda4910f11c0d 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf @@ -17,6 +17,11 @@ Aplikují se změny. + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Výpočet informací Encapsulate Field diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf index 7c5542620b5d3..223527ee2ae83 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf @@ -17,6 +17,11 @@ Änderungen werden übernommen + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Berechnen von "Kapselungsfeld"-Informationen diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf index 7def27cefa87b..8f96fcc9c21d7 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf @@ -17,6 +17,11 @@ Aplicando cambios + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Calculando información de "Encapsular campo" diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf index 77e83a00bb46b..cd4dc9731af30 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf @@ -17,6 +17,11 @@ Application des changements + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Calcul des informations « Encapsuler le champ » diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf index 494d58240b5f9..264651a81a1d2 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf @@ -17,6 +17,11 @@ Applicazione delle modifiche in corso + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Calcolo delle informazioni su 'Incapsula campo' diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf index 173a32b73c844..162b9ff3a5da9 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf @@ -17,6 +17,11 @@ 変更の適用 + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information 'フィールドのカプセル化' 情報を計算中 diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf index 6af82a2e1d86a..967a8c3d65f76 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf @@ -17,6 +17,11 @@ 변경 내용 적용 + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information 'Encapsulate Field' 정보 계산 diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf index db20f5ea0e5ab..13c31e460e558 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf @@ -17,6 +17,11 @@ Stosowanie zmian + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Obliczanie informacji „Hermetyzuj pole” diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf index 3106e84c43329..f0b76297e818e 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf @@ -17,6 +17,11 @@ Aplicando mudanças + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Computando informações de 'Encapsular Campo' diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf index 159f84ac42a3b..882882e284155 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf @@ -17,6 +17,11 @@ Применение изменений + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information Вычисление сведений "Инкапсуляция поля" diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf index 98f893e21b5cc..6aff6dc59e379 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf @@ -17,6 +17,11 @@ Değişiklikler uygulanıyor + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information 'Alanı Kapsülle' bilgileri hesaplanıyor diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf index e626b6675a912..0bed7187047f0 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf @@ -17,6 +17,11 @@ 应用更改 + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information 计算“封装字段”信息 diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf index 3ef849680bea5..7daf637ef2194 100644 --- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf +++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf @@ -17,6 +17,11 @@ 正在套用變更 + + Chat limit reached, [upgrade now] or wait for the limit to reset. + Chat limit reached, [upgrade now] or wait for the limit to reset. + The text surrounded by "[" and "]" characters will be hyperlinked. Please ensure the localized text still has "[" and "]" characters. + Computing 'Encapsulate Field' information 正在計算 [封裝欄位] 資訊 diff --git a/src/EditorFeatures/ExternalAccess/Copilot/Analyzer/IExternalCSharpCopilotCodeAnalysisService.cs b/src/EditorFeatures/ExternalAccess/Copilot/Analyzer/IExternalCSharpCopilotCodeAnalysisService.cs index 3a8485c1f14b2..1a0fed9bd383b 100644 --- a/src/EditorFeatures/ExternalAccess/Copilot/Analyzer/IExternalCSharpCopilotCodeAnalysisService.cs +++ b/src/EditorFeatures/ExternalAccess/Copilot/Analyzer/IExternalCSharpCopilotCodeAnalysisService.cs @@ -18,6 +18,6 @@ internal interface IExternalCSharpCopilotCodeAnalysisService Task> AnalyzeDocumentAsync(Document document, TextSpan? span, string promptTitle, CancellationToken cancellationToken); Task> GetCachedDiagnosticsAsync(Document document, string promptTitle, CancellationToken cancellationToken); Task StartRefinementSessionAsync(Document oldDocument, Document newDocument, Diagnostic? primaryDiagnostic, CancellationToken cancellationToken); - Task GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken); + Task<(string responseString, bool isQuotaExceeded)> GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken); Task IsFileExcludedAsync(string filePath, CancellationToken cancellationToken); } diff --git a/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/AbstractCopilotCodeAnalysisService.cs b/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/AbstractCopilotCodeAnalysisService.cs index 1c0353b079b42..a75f5e8f6f026 100644 --- a/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/AbstractCopilotCodeAnalysisService.cs +++ b/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/AbstractCopilotCodeAnalysisService.cs @@ -39,7 +39,7 @@ internal abstract class AbstractCopilotCodeAnalysisService(IDiagnosticsRefresher protected abstract Task> AnalyzeDocumentCoreAsync(Document document, TextSpan? span, string promptTitle, CancellationToken cancellationToken); protected abstract Task> GetCachedDiagnosticsCoreAsync(Document document, string promptTitle, CancellationToken cancellationToken); protected abstract Task StartRefinementSessionCoreAsync(Document oldDocument, Document newDocument, Diagnostic? primaryDiagnostic, CancellationToken cancellationToken); - protected abstract Task GetOnTheFlyDocsCoreAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken); + protected abstract Task<(string responseString, bool isQuotaExceeded)> GetOnTheFlyDocsCoreAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken); protected abstract Task IsFileExcludedCoreAsync(string filePath, CancellationToken cancellationToken); public Task IsAvailableAsync(CancellationToken cancellationToken) @@ -173,10 +173,10 @@ public async Task StartRefinementSessionAsync(Document oldDocument, Document new await StartRefinementSessionCoreAsync(oldDocument, newDocument, primaryDiagnostic, cancellationToken).ConfigureAwait(false); } - public async Task GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken) + public async Task<(string responseString, bool isQuotaExceeded)> GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken) { if (!await IsAvailableAsync(cancellationToken).ConfigureAwait(false)) - return string.Empty; + return (string.Empty, false); return await GetOnTheFlyDocsCoreAsync(symbolSignature, declarationCode, language, cancellationToken).ConfigureAwait(false); } diff --git a/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.ReflectionWrapper.cs b/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.ReflectionWrapper.cs index 7b3b41c63c1c6..6f33ec3b27cf8 100644 --- a/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.ReflectionWrapper.cs +++ b/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.ReflectionWrapper.cs @@ -19,7 +19,7 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.Copilot.Internal.Analyzer.CSharp using GetCachedDiagnosticsAsyncDelegateType = Func>>; using IsAvailableAsyncDelegateType = Func>; using StartRefinementSessionAsyncDelegateType = Func; -using GetOnTheFlyDocsAsyncDelegateType = Func, string, CancellationToken, Task>; +using GetOnTheFlyDocsAsyncDelegateType = Func, string, CancellationToken, Task<(string responseString, bool isQuotaExceeded)>>; using IsAnyExclusionAsyncDelegateType = Func>; using IsFileExcludedAsyncDelegateType = Func>; @@ -159,10 +159,10 @@ public Task StartRefinementSessionAsync(Document oldDocument, Document newDocume return _lazyStartRefinementSessionAsyncDelegate.Value(oldDocument, newDocument, primaryDiagnostic, cancellationToken); } - public async Task GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken) + public async Task<(string responseString, bool isQuotaExceeded)> GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken) { if (_lazyGetOnTheFlyDocsAsyncDelegate.Value is null) - return string.Empty; + return (string.Empty, false); return await _lazyGetOnTheFlyDocsAsyncDelegate.Value(symbolSignature, declarationCode, language, cancellationToken).ConfigureAwait(false); } diff --git a/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.cs b/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.cs index 317a234a68c11..8d5a5a91088af 100644 --- a/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.cs +++ b/src/EditorFeatures/ExternalAccess/Copilot/Internal/Analyzer/CSharp/CSharpCopilotCodeAnalysisService.cs @@ -57,7 +57,7 @@ protected override Task IsAvailableCoreAsync(CancellationToken cancellatio protected override Task StartRefinementSessionCoreAsync(Document oldDocument, Document newDocument, Diagnostic? primaryDiagnostic, CancellationToken cancellationToken) => _lazyExternalCopilotService.Value.StartRefinementSessionAsync(oldDocument, newDocument, primaryDiagnostic, cancellationToken); - protected override Task GetOnTheFlyDocsCoreAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken) + protected override Task<(string responseString, bool isQuotaExceeded)> GetOnTheFlyDocsCoreAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken) => _lazyExternalCopilotService.Value.GetOnTheFlyDocsAsync(symbolSignature, declarationCode, language, cancellationToken); protected override async Task> GetDiagnosticsIntersectWithSpanAsync( diff --git a/src/EditorFeatures/ExternalAccess/Copilot/InternalAPI.Unshipped.txt b/src/EditorFeatures/ExternalAccess/Copilot/InternalAPI.Unshipped.txt index 9f06d5d62b1b3..546acd188e8fa 100644 --- a/src/EditorFeatures/ExternalAccess/Copilot/InternalAPI.Unshipped.txt +++ b/src/EditorFeatures/ExternalAccess/Copilot/InternalAPI.Unshipped.txt @@ -8,7 +8,7 @@ Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysis Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.AnalyzeDocumentAsync(Microsoft.CodeAnalysis.Document! document, Microsoft.CodeAnalysis.Text.TextSpan? span, string! promptTitle, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task>! Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.GetAvailablePromptTitlesAsync(Microsoft.CodeAnalysis.Document! document, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task>! Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.GetCachedDiagnosticsAsync(Microsoft.CodeAnalysis.Document! document, string! promptTitle, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task>! -Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.GetOnTheFlyDocsAsync(string! symbolSignature, System.Collections.Immutable.ImmutableArray declarationCode, string! language, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! +Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.GetOnTheFlyDocsAsync(string! symbolSignature, System.Collections.Immutable.ImmutableArray declarationCode, string! language, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<(string! responseString, bool isQuotaExceeded)>! Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.IsAvailableAsync(System.Threading.CancellationToken cancellation) -> System.Threading.Tasks.Task! Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.IsFileExcludedAsync(string! filePath, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! Microsoft.CodeAnalysis.ExternalAccess.Copilot.IExternalCSharpCopilotCodeAnalysisService.StartRefinementSessionAsync(Microsoft.CodeAnalysis.Document! oldDocument, Microsoft.CodeAnalysis.Document! newDocument, Microsoft.CodeAnalysis.Diagnostic? primaryDiagnostic, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! diff --git a/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb b/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb index 466596e4df790..f2daa492cf9c6 100644 --- a/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb +++ b/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb @@ -351,8 +351,8 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests Return Task.CompletedTask End Function - Public Function GetOnTheFlyDocsAsync(symbolSignature As String, declarationCode As ImmutableArray(Of String), language As String, cancellationToken As CancellationToken) As Task(Of String) Implements ICopilotCodeAnalysisService.GetOnTheFlyDocsAsync - Return Task.FromResult("") + Public Function GetOnTheFlyDocsAsync(symbolSignature As String, declarationCode As ImmutableArray(Of String), language As String, cancellationToken As CancellationToken) As Task(Of (responseString As String, isQuotaExceeded As Boolean)) Implements ICopilotCodeAnalysisService.GetOnTheFlyDocsAsync + Return Task.FromResult(("", False)) End Function Public Function IsFileExcludedAsync(filePath As String, cancellationToken As CancellationToken) As Task(Of Boolean) Implements ICopilotCodeAnalysisService.IsFileExcludedAsync diff --git a/src/Features/Core/Portable/Copilot/ICopilotCodeAnalysisService.cs b/src/Features/Core/Portable/Copilot/ICopilotCodeAnalysisService.cs index 0bdd083ad9584..a4ce548bcfa7c 100644 --- a/src/Features/Core/Portable/Copilot/ICopilotCodeAnalysisService.cs +++ b/src/Features/Core/Portable/Copilot/ICopilotCodeAnalysisService.cs @@ -70,7 +70,7 @@ internal interface ICopilotCodeAnalysisService : ILanguageService /// is the language of the originating . /// /// - Task GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken); + Task<(string responseString, bool isQuotaExceeded)> GetOnTheFlyDocsAsync(string symbolSignature, ImmutableArray declarationCode, string language, CancellationToken cancellationToken); /// /// Determines if the given is excluded in the workspace. From 2d1799f8ea64acc0a24679d2b2d7c177a6d9e016 Mon Sep 17 00:00:00 2001 From: Jared Parsons Date: Thu, 23 Jan 2025 21:57:21 +0000 Subject: [PATCH 39/76] Testing time (#76873) Couple of changes: - Use the new `INumber` to simplify the partitioning code - Cleaned up partition strategy a bit to put long tests into a dedicated work item - Log tests that exceed work item time slice to the console --- .../Source/RunTests/AssemblyScheduler.cs | 150 +++++++++--------- 1 file changed, 78 insertions(+), 72 deletions(-) diff --git a/src/Tools/Source/RunTests/AssemblyScheduler.cs b/src/Tools/Source/RunTests/AssemblyScheduler.cs index e68e3c380e693..f0066068b777c 100644 --- a/src/Tools/Source/RunTests/AssemblyScheduler.cs +++ b/src/Tools/Source/RunTests/AssemblyScheduler.cs @@ -5,8 +5,10 @@ using System; using System.Collections.Generic; using System.Collections.Immutable; +using System.Diagnostics; using System.IO; using System.Linq; +using System.Numerics; using System.Reflection.Metadata; using System.Reflection.PortableExecutable; using System.Text.Json; @@ -48,15 +50,17 @@ public static ImmutableArray Schedule( { // We didn't have any test history from azure devops, just partition by test count. ConsoleUtil.Warning($"Could not look up test history - partitioning based on test count instead"); - var workItemsByMethodCount = BuildWorkItems( + var workItemsByMethodCount = BuildWorkItems( orderedTypeInfos, - isOverLimitFunc: static (accumulatedMethodCount) => accumulatedMethodCount >= s_maxMethodCount, - addFunc: static (currentTest, accumulatedMethodCount) => accumulatedMethodCount + 1); + getWeightFunc: static test => 1, + limit: s_maxMethodCount); LogWorkItems(workItemsByMethodCount); return workItemsByMethodCount; } + LogLongTests(testHistory); + // Now for our current set of test methods we got from the assemblies we built, match them to tests from our test run history // so that we can extract an estimate of the test execution time for each test. orderedTypeInfos = UpdateTestsWithExecutionTimes(orderedTypeInfos, testHistory); @@ -64,14 +68,30 @@ public static ImmutableArray Schedule( // Create work items by partitioning tests by historical execution time with the goal of running under our time limit. // While we do our best to run tests from the same assembly together (by building work items in assembly order) it is expected // that some work items will run tests from multiple assemblies due to large variances in test execution time. - var workItems = BuildWorkItems( + var workItems = BuildWorkItems( orderedTypeInfos, - isOverLimitFunc: static (accumulatedExecutionTime) => accumulatedExecutionTime >= s_maxExecutionTime, - addFunc: static (currentTest, accumulatedExecutionTime) => currentTest.ExecutionTime + accumulatedExecutionTime); + getWeightFunc: static test => test.ExecutionTime.TotalSeconds, + limit: s_maxExecutionTime.TotalSeconds); LogWorkItems(workItems); return workItems; } + private static void LogLongTests(ImmutableDictionary testHistory) + { + var longTests = testHistory + .Where(kvp => kvp.Value > s_maxExecutionTime) + .OrderBy(kvp => kvp.Key) + .ToList(); + if (longTests.Count > 0) + { + ConsoleUtil.Warning($"There are {longTests.Count} tests have execution times greater than the maximum execution time of {s_maxExecutionTime}"); + foreach (var (test, time) in longTests) + { + ConsoleUtil.WriteLine($"\t{test} - {time:hh\\:mm\\:ss}"); + } + } + } + private static ImmutableSortedDictionary> UpdateTestsWithExecutionTimes( ImmutableSortedDictionary> assemblyTypes, ImmutableDictionary testHistory) @@ -137,105 +157,91 @@ void WriteResults() private static ImmutableArray BuildWorkItems( ImmutableSortedDictionary> typeInfos, - Func isOverLimitFunc, - Func addFunc) where TWeight : struct + Func getWeightFunc, + TWeight limit) + where TWeight : struct, INumber { var workItems = new List(); + var currentWeight = TWeight.Zero; + var currentFilters = new List<(string AssemblyFilePath, TestMethodInfo TestMethodInfo)>(); - // Keep track of the limit of the current work item we are adding to. - var accumulatedValue = default(TWeight); - - // Keep track of the types we're planning to add to the current work item. The key - // is the file path of the assembly - var currentFilters = new SortedDictionary>(); - - // First find any assemblies we need to run in single assembly work items (due to state sharing concerns). - var singlePartitionAssemblies = typeInfos.Where(kvp => ShouldPartitionInSingleWorkItem(kvp.Key)); - typeInfos = typeInfos.RemoveRange(singlePartitionAssemblies.Select(kvp => kvp.Key)); - foreach (var (assemblyFilePaths, types) in singlePartitionAssemblies) - { - ConsoleUtil.WriteLine($"Building single assembly work item {workItems.Count} for {assemblyFilePaths}"); - types.SelectMany(t => t.Tests).ToList().ForEach(test => AddFilter(assemblyFilePaths, test)); - - // End the work item so we don't include anything after this assembly. - AddCurrentWorkItem(); - } - - // Iterate through each assembly and type and build up the work items to run. - // We add types from assemblies one by one until we hit our limit, - // at which point we create a work item with the current types and start a new one. foreach (var (assemblyFilePath, types) in typeInfos) { + if (ShouldPartitionInSingleWorkItem(assemblyFilePath)) + { + AddWorkItem(types.SelectMany(x => x.Tests).Select(x => (assemblyFilePath, x))); + continue; + } + foreach (var type in types) { foreach (var test in type.Tests) { - // Get a new value representing the value from the test plus the accumulated value in the work item. - var newAccumulatedValue = addFunc(test, accumulatedValue); + var weight = getWeightFunc(test); + + // When the single test is greater than the limit, give it a dedicated work item + if (weight > limit) + { + AddWorkItem([(assemblyFilePath, test)]); + continue; + } + + currentWeight += weight; - // If the new accumulated value is greater than the limit - if (isOverLimitFunc(newAccumulatedValue)) + // If the accumulated value is greater than the limit then we close off the current + // work item and start a new one + if (currentWeight > limit) { - // Adding this type would put us over the time limit for this partition. - // Add the current work item to our list and start a new one. - AddCurrentWorkItem(); + MaybeAddCurrentWorkItem(); + currentWeight = weight; } - // Update the current group in the work item with this new type. - AddFilter(assemblyFilePath, test); + currentFilters.Add((assemblyFilePath, test)); } } } - // Add any remaining tests to the work item. - AddCurrentWorkItem(); + MaybeAddCurrentWorkItem(); return workItems.ToImmutableArray(); - void AddCurrentWorkItem() + void MaybeAddCurrentWorkItem() { - if (currentFilters.Any()) + if (currentFilters.Count > 0) { - var e = currentFilters.Values - .SelectMany(v => v) - .Sum(v => v.ExecutionTime.TotalSeconds); - var workItemInfo = new HelixWorkItem( - workItems.Count, - currentFilters.Keys.ToImmutableArray(), - currentFilters.Values.SelectMany(v => v).Select(x => x.FullyQualifiedName).ToImmutableArray(), - TimeSpan.FromSeconds(e)); - workItems.Add(workItemInfo); + AddWorkItem(currentFilters); + currentFilters.Clear(); + currentWeight = TWeight.Zero; } - - currentFilters.Clear(); - accumulatedValue = default; } - void AddFilter(string assemblyFilePath, TestMethodInfo test) + void AddWorkItem(params IEnumerable<(string AssemblyFilePath, TestMethodInfo TestMethodInfo)> tests) { - if (!currentFilters.TryGetValue(assemblyFilePath, out var assemblyFilters)) - { - assemblyFilters = new List(); - currentFilters.Add(assemblyFilePath, assemblyFilters); - } - - assemblyFilters.Add(test); - accumulatedValue = addFunc(test, accumulatedValue); + Debug.Assert(tests.Any()); + var assemblyFilePaths = tests + .Select(x => x.AssemblyFilePath) + .Distinct() + .Order() + .ToImmutableArray(); + var testMethodNames = tests + .Select(x => x.TestMethodInfo.FullyQualifiedName) + .ToImmutableArray(); + var executionTime = tests + .Sum(x => x.TestMethodInfo.ExecutionTime.TotalSeconds); + var workItem = new HelixWorkItem( + workItems.Count, + assemblyFilePaths, + testMethodNames, + TimeSpan.FromSeconds(executionTime)); + workItems.Add(workItem); } } private static void LogWorkItems(ImmutableArray workItems) { ConsoleUtil.WriteLine($"Built {workItems.Length} work items"); - ConsoleUtil.WriteLine("==== Work Item List ===="); foreach (var workItem in workItems) { - ConsoleUtil.WriteLine($"- Work Item {workItem.Id} (Execution time {workItem.EstimatedExecutionTime})"); - if (workItem.EstimatedExecutionTime > s_maxExecutionTime == true) - { - // Log a warning to the console with work item details when we were not able to partition in under our limit. - // This can happen when a single specific test exceeds our execution time limit. - ConsoleUtil.Warning($"Estimated execution {workItem.EstimatedExecutionTime} time exceeds max execution time {s_maxExecutionTime}."); - } + ConsoleUtil.WriteLine($"- Work Item: {workItem.Id} Execution time: {workItem.EstimatedExecutionTime:hh\\:mm\\:ss}"); } } From 3a8c9a83cc831a2422df2a1950937fcfea749718 Mon Sep 17 00:00:00 2001 From: Chris Sienkiewicz Date: Thu, 23 Jan 2025 14:48:25 -0800 Subject: [PATCH 40/76] Fix throw in generator comparer (#76769) * Add a test that fails * Clean up strategies that always have a comparer * Cleanup comparers in nodes: All nodes either passed in a default comparer or null, which was stored in the node table. Modifications then had the option to supply a seperate comparer to do the modification. In all cases the comparer passed into the modify call was the same as the one passed when creating the table, so we can remove the call from modify and just use the table instance. Rather than each node passing it its own default when it doesn't have a comparer, just pass in null and let the table control creating the default. * Use a wrapped comparer as the default comparer --- .../SourceGeneration/GeneratorDriverTests.cs | 48 +++++++++++++++++++ .../SourceGeneration/StateTableTests.cs | 26 +++++----- .../SourceGeneration/Nodes/BatchNode.cs | 6 +-- .../SourceGeneration/Nodes/CombineNode.cs | 2 +- .../SourceGeneration/Nodes/InputNode.cs | 6 +-- .../SourceGeneration/Nodes/NodeStateTable.cs | 20 ++++---- .../Nodes/PredicateSyntaxStrategy.cs | 8 ++-- .../Nodes/SourceOutputNode.cs | 6 +-- .../Nodes/SyntaxReceiverStrategy.cs | 2 +- .../SourceGeneration/Nodes/TransformNode.cs | 6 +-- .../Portable/SourceGeneration/UserFunction.cs | 2 + 11 files changed, 91 insertions(+), 41 deletions(-) diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs index c1633ff05187d..58d7a89a0ae22 100644 --- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs +++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs @@ -1525,6 +1525,54 @@ [Attr] class D { } Assert.Equal(e, runResults.Results.Single().Exception); } + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76765")] + public void Incremental_Generators_Exception_In_DefaultComparer() + { + var source = """ + class C { } + """; + var parseOptions = TestOptions.RegularPreview; + Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDllThrowing, parseOptions: parseOptions); + compilation.VerifyDiagnostics(); + + var syntaxTree = compilation.SyntaxTrees.Single(); + + var e = new InvalidOperationException("abc"); + var generator = new PipelineCallbackGenerator((ctx) => + { + var name = ctx.CompilationProvider.Select((c, _) => new ThrowWhenEqualsItem(e)); + ctx.RegisterSourceOutput(name, (spc, n) => spc.AddSource("item.cs", "// generated")); + }); + + GeneratorDriver driver = CSharpGeneratorDriver.Create([generator.AsSourceGenerator()], parseOptions: parseOptions); + driver = driver.RunGenerators(compilation); + var runResults = driver.GetRunResult(); + + Assert.Empty(runResults.Diagnostics); + Assert.Equal("// generated", runResults.Results.Single().GeneratedSources.Single().SourceText.ToString()); + + compilation = compilation.ReplaceSyntaxTree(syntaxTree, CSharpSyntaxTree.ParseText(""" + class D { } + """, parseOptions)); + compilation.VerifyDiagnostics(); + + driver = driver.RunGenerators(compilation); + runResults = driver.GetRunResult(); + + VerifyGeneratorExceptionDiagnostic(runResults.Diagnostics.Single(), nameof(PipelineCallbackGenerator), "abc"); + Assert.Empty(runResults.GeneratedTrees); + Assert.Equal(e, runResults.Results.Single().Exception); + } + + class ThrowWhenEqualsItem(Exception toThrow) + { + readonly Exception _toThrow = toThrow; + + public override bool Equals(object? obj) => throw _toThrow; + + public override int GetHashCode() => throw new NotImplementedException(); + } + [Fact] public void Incremental_Generators_Exception_During_Execution_Doesnt_Produce_AnySource() { diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs index bb887e87ce6ec..e075bce56677d 100644 --- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs +++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs @@ -82,9 +82,9 @@ public void Node_Builder_Can_Add_Entries_From_Previous_Table() var previousTable = builder.ToImmutableAndFree(); builder = previousTable.ToBuilder(stepName: null, false); - builder.TryModifyEntries(ImmutableArray.Create(10, 11), EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified); + builder.TryModifyEntries(ImmutableArray.Create(10, 11), TimeSpan.Zero, default, EntryState.Modified); builder.TryUseCachedEntries(TimeSpan.Zero, default, out var cachedEntries); // ((2, EntryState.Cached), (3, EntryState.Cached)) - builder.TryModifyEntries(ImmutableArray.Create(20, 21, 22), EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified); + builder.TryModifyEntries(ImmutableArray.Create(20, 21, 22), TimeSpan.Zero, default, EntryState.Modified); bool didRemoveEntries = builder.TryRemoveEntries(TimeSpan.Zero, default, out var removedEntries); //((6, EntryState.Removed)) var newTable = builder.ToImmutableAndFree(); @@ -185,9 +185,9 @@ public void Node_Builder_Handles_Modification_When_Both_Tables_Have_Empty_Entrie AssertTableEntries(previousTable, expected); builder = previousTable.ToBuilder(stepName: null, false); - Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 2), EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); - Assert.True(builder.TryModifyEntries(ImmutableArray.Empty, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); - Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 5), EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 2), TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntries(ImmutableArray.Empty, TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 5), TimeSpan.Zero, default, EntryState.Modified)); var newTable = builder.ToImmutableAndFree(); @@ -209,10 +209,10 @@ public void Node_Table_Doesnt_Modify_Single_Item_Multiple_Times_When_Same() AssertTableEntries(previousTable, expected); builder = previousTable.ToBuilder(stepName: null, false); - Assert.True(builder.TryModifyEntry(1, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); - Assert.True(builder.TryModifyEntry(2, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); - Assert.True(builder.TryModifyEntry(5, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); - Assert.True(builder.TryModifyEntry(4, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntry(1, TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntry(2, TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntry(5, TimeSpan.Zero, default, EntryState.Modified)); + Assert.True(builder.TryModifyEntry(4, TimeSpan.Zero, default, EntryState.Modified)); var newTable = builder.ToImmutableAndFree(); @@ -232,10 +232,10 @@ public void Node_Table_Caches_Previous_Object_When_Modification_Considered_Cache var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 0), (3, EntryState.Added, 0)); AssertTableEntries(previousTable, expected); - builder = previousTable.ToBuilder(stepName: null, false); - Assert.True(builder.TryModifyEntry(1, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); // ((1, EntryState.Cached)) - Assert.True(builder.TryModifyEntry(4, EqualityComparer.Default, TimeSpan.Zero, default, EntryState.Modified)); // ((4, EntryState.Modified)) - Assert.True(builder.TryModifyEntry(5, new LambdaComparer((i, j) => true), TimeSpan.Zero, default, EntryState.Modified)); // ((3, EntryState.Cached)) + builder = previousTable.ToBuilder(stepName: null, false, new LambdaComparer((i, j) => i == 3 || i == j)); + Assert.True(builder.TryModifyEntry(1, TimeSpan.Zero, default, EntryState.Modified)); // ((1, EntryState.Cached)) + Assert.True(builder.TryModifyEntry(4, TimeSpan.Zero, default, EntryState.Modified)); // ((4, EntryState.Modified)) + Assert.True(builder.TryModifyEntry(5, TimeSpan.Zero, default, EntryState.Modified)); // ((3, EntryState.Cached)) var newTable = builder.ToImmutableAndFree(); expected = ImmutableArray.Create((1, EntryState.Cached, 0), (4, EntryState.Modified, 0), (3, EntryState.Cached, 0)); diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs index 3b803f961498b..f8c92b1791cde 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs @@ -16,13 +16,13 @@ internal sealed class BatchNode : IIncrementalGeneratorNode).FullName; private readonly IIncrementalGeneratorNode _sourceNode; - private readonly IEqualityComparer> _comparer; + private readonly IEqualityComparer>? _comparer; private readonly string? _name; public BatchNode(IIncrementalGeneratorNode sourceNode, IEqualityComparer>? comparer = null, string? name = null) { _sourceNode = sourceNode; - _comparer = comparer ?? EqualityComparer>.Default; + _comparer = comparer; _name = name; } @@ -136,7 +136,7 @@ public NodeStateTable> UpdateStateTable(DriverStateTable. } else if (!sourceTable.IsCached || !tableBuilder.TryUseCachedEntries(stopwatch.Elapsed, sourceInputs)) { - if (!tableBuilder.TryModifyEntry(sourceValues, _comparer, stopwatch.Elapsed, sourceInputs, EntryState.Modified)) + if (!tableBuilder.TryModifyEntry(sourceValues, stopwatch.Elapsed, sourceInputs, EntryState.Modified)) { tableBuilder.AddEntry(sourceValues, EntryState.Added, stopwatch.Elapsed, sourceInputs, EntryState.Added); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs index bd4c0d4c489c5..67795541805fb 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs @@ -72,7 +72,7 @@ public CombineNode(IIncrementalGeneratorNode input1, IIncrementalGenera }; var entry = (entry1.Item, input2); - if (state != EntryState.Modified || _comparer is null || !tableBuilder.TryModifyEntry(entry, _comparer, stopwatch.Elapsed, stepInputs, state)) + if (state != EntryState.Modified || _comparer is null || !tableBuilder.TryModifyEntry(entry, stopwatch.Elapsed, stepInputs, state)) { tableBuilder.AddEntry(entry, state, stopwatch.Elapsed, stepInputs, state); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs index 2e7205b08793e..66b8cfe04e012 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs @@ -24,7 +24,7 @@ internal sealed class InputNode : IIncrementalGeneratorNode private readonly Func> _getInput; private readonly Action _registerOutput; private readonly IEqualityComparer _inputComparer; - private readonly IEqualityComparer _comparer; + private readonly IEqualityComparer? _comparer; private readonly string? _name; public InputNode(Func> getInput, IEqualityComparer? inputComparer = null) @@ -35,7 +35,7 @@ public InputNode(Func> getInput, IEq private InputNode(Func> getInput, Action? registerOutput, IEqualityComparer? inputComparer = null, IEqualityComparer? comparer = null, string? name = null) { _getInput = getInput; - _comparer = comparer ?? EqualityComparer.Default; + _comparer = comparer; _inputComparer = inputComparer ?? EqualityComparer.Default; _registerOutput = registerOutput ?? (o => throw ExceptionUtilities.Unreachable()); _name = name; @@ -83,7 +83,7 @@ public NodeStateTable UpdateStateTable(DriverStateTable.Builder graphState, N // This allows us to correctly 'replace' items even when they aren't actually the same. In the case that the // item really isn't modified, but a new item, we still function correctly as we mostly treat them the same, // but will perform an extra comparison that is omitted in the pure 'added' case. - var modified = tableBuilder.TryModifyEntry(inputItems[itemIndex], _comparer, elapsedTime, noInputStepsStepInfo, EntryState.Modified); + var modified = tableBuilder.TryModifyEntry(inputItems[itemIndex], elapsedTime, noInputStepsStepInfo, EntryState.Modified); Debug.Assert(modified); itemsSet.Remove(inputItems[itemIndex]); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs index 8758c9302a75a..d166d64ec62ff 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs @@ -183,7 +183,7 @@ public NodeStateTable AsCached() public Builder ToBuilder(string? stepName, bool stepTrackingEnabled, IEqualityComparer? equalityComparer = null, int? tableCapacity = null) => new(this, stepName, stepTrackingEnabled, equalityComparer, tableCapacity); - public NodeStateTable CreateCachedTableWithUpdatedSteps(NodeStateTable inputTable, string? stepName, IEqualityComparer equalityComparer) + public NodeStateTable CreateCachedTableWithUpdatedSteps(NodeStateTable inputTable, string? stepName, IEqualityComparer? equalityComparer) { Debug.Assert(inputTable.HasTrackedSteps && inputTable.IsCached); NodeStateTable.Builder builder = ToBuilder(stepName, stepTrackingEnabled: true, equalityComparer); @@ -256,7 +256,7 @@ internal Builder( _states = ArrayBuilder.GetInstance(tableCapacity ?? previous.GetTotalEntryItemCount()); _previous = previous; _name = name; - _equalityComparer = equalityComparer ?? EqualityComparer.Default; + _equalityComparer = equalityComparer ?? WrappedUserComparer.Default; if (stepTrackingEnabled) { _steps = ArrayBuilder.GetInstance(); @@ -320,7 +320,7 @@ internal bool TryUseCachedEntries(TimeSpan elapsedTime, ImmutableArray<(Incremen return true; } - public bool TryModifyEntry(T value, IEqualityComparer comparer, TimeSpan elapsedTime, ImmutableArray<(IncrementalGeneratorRunStep InputStep, int OutputIndex)> stepInputs, EntryState overallInputState) + public bool TryModifyEntry(T value, TimeSpan elapsedTime, ImmutableArray<(IncrementalGeneratorRunStep InputStep, int OutputIndex)> stepInputs, EntryState overallInputState) { if (!TryGetPreviousEntry(out var previousEntry)) { @@ -335,13 +335,13 @@ public bool TryModifyEntry(T value, IEqualityComparer comparer, TimeSpan elap } Debug.Assert(previousEntry.Count == 1); - var (chosen, state, _) = GetModifiedItemAndState(previousEntry.GetItem(0), value, comparer); + var (chosen, state, _) = GetModifiedItemAndState(previousEntry.GetItem(0), value); _states.Add(new TableEntry(OneOrMany.Create(chosen), state)); RecordStepInfoForLastEntry(elapsedTime, stepInputs, overallInputState); return true; } - public bool TryModifyEntries(ImmutableArray outputs, IEqualityComparer comparer, TimeSpan elapsedTime, ImmutableArray<(IncrementalGeneratorRunStep InputStep, int OutputIndex)> stepInputs, EntryState overallInputState) + public bool TryModifyEntries(ImmutableArray outputs, TimeSpan elapsedTime, ImmutableArray<(IncrementalGeneratorRunStep InputStep, int OutputIndex)> stepInputs, EntryState overallInputState) { // Semantics: // For each item in the row, we compare with the new matching new value. @@ -384,7 +384,7 @@ public bool TryModifyEntries(ImmutableArray outputs, IEqualityComparer com var previousState = previousEntry.GetState(i); var replacementItem = outputs[i]; - var (chosenItem, state, chosePrevious) = GetModifiedItemAndState(previousItem, replacementItem, comparer); + var (chosenItem, state, chosePrevious) = GetModifiedItemAndState(previousItem, replacementItem); if (builder != null) { @@ -433,9 +433,9 @@ public bool TryModifyEntries(ImmutableArray outputs, IEqualityComparer com return true; } - public bool TryModifyEntries(ImmutableArray outputs, IEqualityComparer comparer, TimeSpan elapsedTime, ImmutableArray<(IncrementalGeneratorRunStep InputStep, int OutputIndex)> stepInputs, EntryState overallInputState, out TableEntry entry) + public bool TryModifyEntries(ImmutableArray outputs, TimeSpan elapsedTime, ImmutableArray<(IncrementalGeneratorRunStep InputStep, int OutputIndex)> stepInputs, EntryState overallInputState, out TableEntry entry) { - if (!TryModifyEntries(outputs, comparer, elapsedTime, stepInputs, overallInputState)) + if (!TryModifyEntries(outputs, elapsedTime, stepInputs, overallInputState)) { entry = default; return false; @@ -554,11 +554,11 @@ public NodeStateTable ToImmutableAndFree() isCached: finalStates.All(static s => s.IsCached) && _previous.GetTotalEntryItemCount() == finalStates.Sum(static s => s.Count)); } - private static (T chosen, EntryState state, bool chosePrevious) GetModifiedItemAndState(T previous, T replacement, IEqualityComparer comparer) + private (T chosen, EntryState state, bool chosePrevious) GetModifiedItemAndState(T previous, T replacement) { // when comparing an item to check if its modified we explicitly cache the *previous* item in the case where its // considered to be equal. This ensures that subsequent comparisons are stable across future generation passes. - return comparer.Equals(previous, replacement) + return _equalityComparer.Equals(previous, replacement) ? (previous, EntryState.Cached, chosePrevious: true) : (replacement, EntryState.Modified, chosePrevious: false); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/PredicateSyntaxStrategy.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/PredicateSyntaxStrategy.cs index 540902c29ac9e..e6fc120ee48bd 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/PredicateSyntaxStrategy.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/PredicateSyntaxStrategy.cs @@ -30,7 +30,7 @@ internal PredicateSyntaxStrategy( _filterFunc = filterFunc; } - public ISyntaxInputBuilder GetBuilder(StateTableStore table, object key, bool trackIncrementalSteps, string? name, IEqualityComparer? comparer) => new Builder(this, key, table, trackIncrementalSteps, name, comparer ?? EqualityComparer.Default); + public ISyntaxInputBuilder GetBuilder(StateTableStore table, object key, bool trackIncrementalSteps, string? name, IEqualityComparer comparer) => new Builder(this, key, table, trackIncrementalSteps, name, comparer); private sealed class Builder : ISyntaxInputBuilder { @@ -48,7 +48,7 @@ public Builder(PredicateSyntaxStrategy owner, object key, StateTableStore tab _name = name; _comparer = comparer; _key = key; - _filterTable = table.GetStateTableOrEmpty(_owner._filterKey).ToBuilder(stepName: null, trackIncrementalSteps); + _filterTable = table.GetStateTableOrEmpty(_owner._filterKey).ToBuilder(stepName: null, trackIncrementalSteps, equalityComparer: Roslyn.Utilities.ReferenceEqualityComparer.Instance); _transformTable = table.GetStateTableOrEmpty(_key).ToBuilder(_name, trackIncrementalSteps, _comparer); } @@ -85,7 +85,7 @@ public void VisitTree( var stopwatch = SharedStopwatch.StartNew(); var nodes = getFilteredNodes(root.Value, _owner._filterFunc, cancellationToken); - if (state != EntryState.Modified || !_filterTable.TryModifyEntries(nodes, Roslyn.Utilities.ReferenceEqualityComparer.Instance, stopwatch.Elapsed, noInputStepsStepInfo, state, out entry)) + if (state != EntryState.Modified || !_filterTable.TryModifyEntries(nodes, stopwatch.Elapsed, noInputStepsStepInfo, state, out entry)) { entry = _filterTable.AddEntries(nodes, state, stopwatch.Elapsed, noInputStepsStepInfo, state); } @@ -108,7 +108,7 @@ public void VisitTree( // so we never consider the input to the transform as cached. var transformInputState = state == EntryState.Cached ? EntryState.Modified : state; - if (transformInputState == EntryState.Added || !_transformTable.TryModifyEntry(transformed, _comparer, stopwatch.Elapsed, noInputStepsStepInfo, transformInputState)) + if (transformInputState == EntryState.Added || !_transformTable.TryModifyEntry(transformed, stopwatch.Elapsed, noInputStepsStepInfo, transformInputState)) { _transformTable.AddEntry(transformed, EntryState.Added, stopwatch.Elapsed, noInputStepsStepInfo, EntryState.Added); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs index 79a71f0e2e17a..028a4764d3c66 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs @@ -46,12 +46,12 @@ public NodeStateTable UpdateStateTable(DriverStateTable.Builder graphSt this.LogTables(stepName, s_tableType, previousTable, previousTable, sourceTable); if (graphState.DriverState.TrackIncrementalSteps) { - return previousTable.CreateCachedTableWithUpdatedSteps(sourceTable, stepName, EqualityComparer.Default); + return previousTable.CreateCachedTableWithUpdatedSteps(sourceTable, stepName, equalityComparer: null); } return previousTable; } - var tableBuilder = graphState.CreateTableBuilder(previousTable, stepName, EqualityComparer.Default); + var tableBuilder = graphState.CreateTableBuilder(previousTable, stepName, equalityComparer: null); foreach (var entry in sourceTable) { var inputs = tableBuilder.TrackIncrementalSteps ? ImmutableArray.Create((entry.Step!, entry.OutputIndex)) : default; @@ -71,7 +71,7 @@ public NodeStateTable UpdateStateTable(DriverStateTable.Builder graphSt _action(context, entry.Item, cancellationToken); var sourcesAndDiagnostics = (sourcesBuilder.ToImmutable(), diagnostics.ToReadOnly()); - if (entry.State != EntryState.Modified || !tableBuilder.TryModifyEntry(sourcesAndDiagnostics, EqualityComparer.Default, stopwatch.Elapsed, inputs, entry.State)) + if (entry.State != EntryState.Modified || !tableBuilder.TryModifyEntry(sourcesAndDiagnostics, stopwatch.Elapsed, inputs, entry.State)) { tableBuilder.AddEntry(sourcesAndDiagnostics, EntryState.Added, stopwatch.Elapsed, inputs, EntryState.Added); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverStrategy.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverStrategy.cs index 63b7be100b588..d969dc80a4c90 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverStrategy.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverStrategy.cs @@ -27,7 +27,7 @@ public SyntaxReceiverStrategy( _syntaxHelper = syntaxHelper; } - public ISyntaxInputBuilder GetBuilder(StateTableStore table, object key, bool trackIncrementalSteps, string? name, IEqualityComparer? comparer) => new Builder(this, key, table, trackIncrementalSteps); + public ISyntaxInputBuilder GetBuilder(StateTableStore table, object key, bool trackIncrementalSteps, string? name, IEqualityComparer comparer) => new Builder(this, key, table, trackIncrementalSteps); private sealed class Builder : ISyntaxInputBuilder { diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs index d63edba0ce260..1ff2adb1f2640 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs @@ -18,7 +18,7 @@ internal sealed class TransformNode : IIncrementalGeneratorNode private static readonly string? s_tableType = typeof(TOutput).FullName; private readonly Func> _func; - private readonly IEqualityComparer _comparer; + private readonly IEqualityComparer? _comparer; private readonly IIncrementalGeneratorNode _sourceNode; private readonly string? _name; private readonly bool _wrapUserFunc; @@ -33,7 +33,7 @@ public TransformNode(IIncrementalGeneratorNode sourceNode, Func.Default; + _comparer = comparer; _name = name; } @@ -87,7 +87,7 @@ public NodeStateTable UpdateStateTable(DriverStateTable.Builder builder throw new UserFunctionException(e); } - if (entry.State != EntryState.Modified || !tableBuilder.TryModifyEntries(newOutputs, _comparer, stopwatch.Elapsed, inputs, entry.State)) + if (entry.State != EntryState.Modified || !tableBuilder.TryModifyEntries(newOutputs, stopwatch.Elapsed, inputs, entry.State)) { tableBuilder.AddEntries(newOutputs, EntryState.Added, stopwatch.Elapsed, inputs, entry.State); } diff --git a/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs b/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs index 6aedc61bc6130..64d1588f2955e 100644 --- a/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs +++ b/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs @@ -25,6 +25,8 @@ internal sealed class WrappedUserComparer : IEqualityComparer { private readonly IEqualityComparer _inner; + public static WrappedUserComparer Default { get; } = new WrappedUserComparer(EqualityComparer.Default); + public WrappedUserComparer(IEqualityComparer inner) { _inner = inner; From a30dc72cae662133f7419d6a5503d17a79ce5b1e Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 19:04:51 -0800 Subject: [PATCH 41/76] Convert to full prop should update 'field expressions --- ...tyToFullPropertyCodeRefactoringProvider.cs | 65 ++++++++++--------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 363f5336084e2..a94e4244023a7 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -52,55 +52,56 @@ protected override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNew var accessorListSyntax = property.AccessorList; var (getAccessor, setAccessor) = GetExistingAccessors(accessorListSyntax); - var getAccessorStatement = generator.ReturnStatement(generator.IdentifierName(fieldName)); - var newGetter = GetUpdatedAccessor(info, getAccessor, getAccessorStatement, cancellationToken); + var fieldIdentifier = generator.IdentifierName(fieldName); + var getAccessorStatement = generator.ReturnStatement(fieldIdentifier); + var newGetter = GetUpdatedAccessor(getAccessor, getAccessorStatement); var newSetter = setAccessor; if (newSetter != null) { var setAccessorStatement = generator.ExpressionStatement(generator.AssignmentStatement( - generator.IdentifierName(fieldName), + fieldIdentifier, generator.IdentifierName("value"))); - newSetter = GetUpdatedAccessor(info, setAccessor, setAccessorStatement, cancellationToken); + newSetter = GetUpdatedAccessor(setAccessor, setAccessorStatement); } return (newGetter, newSetter); - } - private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax setAccessor) - GetExistingAccessors(AccessorListSyntax accessorListSyntax) - => (accessorListSyntax.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration)), - accessorListSyntax.Accessors.FirstOrDefault(a => a.Kind() is SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration)); + AccessorDeclarationSyntax GetUpdatedAccessor( + AccessorDeclarationSyntax accessor, SyntaxNode statement) + { + if (accessor.Body != null || accessor.ExpressionBody != null) + return accessor; - private static AccessorDeclarationSyntax GetUpdatedAccessor(CSharpCodeGenerationContextInfo info, - AccessorDeclarationSyntax accessor, SyntaxNode statement, CancellationToken cancellationToken) - { - if (accessor.Body != null || accessor.ExpressionBody != null) - return accessor; + var newAccessor = AddStatement(accessor, statement); + var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor; - var newAccessor = AddStatement(accessor, statement); - var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor; + var preference = info.Options.PreferExpressionBodiedAccessors.Value; + if (preference == ExpressionBodyPreference.Never) + { + return accessorDeclarationSyntax.WithSemicolonToken(default); + } - var preference = info.Options.PreferExpressionBodiedAccessors.Value; - if (preference == ExpressionBodyPreference.Never) - { - return accessorDeclarationSyntax.WithSemicolonToken(default); - } + if (!accessorDeclarationSyntax.Body.TryConvertToArrowExpressionBody( + accessorDeclarationSyntax.Kind(), info.LanguageVersion, preference, cancellationToken, + out var arrowExpression, out _)) + { + return accessorDeclarationSyntax.WithSemicolonToken(default); + } - if (!accessorDeclarationSyntax.Body.TryConvertToArrowExpressionBody( - accessorDeclarationSyntax.Kind(), info.LanguageVersion, preference, cancellationToken, - out var arrowExpression, out _)) - { - return accessorDeclarationSyntax.WithSemicolonToken(default); + return accessorDeclarationSyntax + .WithExpressionBody(arrowExpression) + .WithBody(null) + .WithSemicolonToken(accessorDeclarationSyntax.SemicolonToken) + .WithAdditionalAnnotations(Formatter.Annotation); } - - return accessorDeclarationSyntax - .WithExpressionBody(arrowExpression) - .WithBody(null) - .WithSemicolonToken(accessorDeclarationSyntax.SemicolonToken) - .WithAdditionalAnnotations(Formatter.Annotation); } + private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax setAccessor) + GetExistingAccessors(AccessorListSyntax accessorListSyntax) + => (accessorListSyntax.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration)), + accessorListSyntax.Accessors.FirstOrDefault(a => a.Kind() is SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration)); + internal static SyntaxNode AddStatement(SyntaxNode accessor, SyntaxNode statement) { var blockSyntax = SyntaxFactory.Block( From 3f1e8c5edeb6a4891090364238d70c11ad755331 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 19:11:00 -0800 Subject: [PATCH 42/76] Update test --- ...oPropertyToFullPropertyCodeRefactoringProvider.cs | 12 +++++++++--- .../ConvertAutoPropertyToFullPropertyTests.cs | 6 +++--- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index a94e4244023a7..97d5afdd92d3c 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -67,11 +67,10 @@ protected override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNew return (newGetter, newSetter); - AccessorDeclarationSyntax GetUpdatedAccessor( - AccessorDeclarationSyntax accessor, SyntaxNode statement) + AccessorDeclarationSyntax GetUpdatedAccessor(AccessorDeclarationSyntax accessor, SyntaxNode statement) { if (accessor.Body != null || accessor.ExpressionBody != null) - return accessor; + return ReplaceFieldExpression(accessor); var newAccessor = AddStatement(accessor, statement); var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor; @@ -95,6 +94,13 @@ AccessorDeclarationSyntax GetUpdatedAccessor( .WithSemicolonToken(accessorDeclarationSyntax.SemicolonToken) .WithAdditionalAnnotations(Formatter.Annotation); } + + AccessorDeclarationSyntax ReplaceFieldExpression(AccessorDeclarationSyntax accessor) + { + return accessor.ReplaceNodes( + accessor.DescendantNodes().OfType(), + (oldNode, _) => fieldIdentifier.WithTriviaFrom(oldNode)); + } } private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax setAccessor) diff --git a/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs b/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs index 1b2b5314f5350..fc758d25c61b1 100644 --- a/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs +++ b/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs @@ -14,7 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertAutoPropertyToFullProperty; [Trait(Traits.Feature, Traits.Features.ConvertAutoPropertyToFullProperty)] -public partial class ConvertAutoPropertyToFullPropertyTests : AbstractCSharpCodeActionTest_NoEditor +public sealed partial class ConvertAutoPropertyToFullPropertyTests : AbstractCSharpCodeActionTest_NoEditor { private static readonly CSharpParseOptions s_preview = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Preview); @@ -1384,8 +1384,8 @@ int [||]P get => p; set { - M(field); - field = value; + M(p); + p = value; } } From e76e4f9b09f7c6020ea341b17d3340e34c433a17 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 19:29:55 -0800 Subject: [PATCH 43/76] in progress --- .../CSharpUseAutoPropertyAnalyzer.cs | 15 +------------- .../UseAutoPropertyTests_Field.cs | 3 ++- ...UseImplicitlyTypedLambdaExpressionTests.cs | 3 ++- .../AbstractUseAutoPropertyAnalyzer.cs | 14 ++++++------- ...tyToFullPropertyCodeRefactoringProvider.cs | 7 +++++++ .../ConvertAutoPropertyToFullPropertyTests.cs | 3 ++- ...tyToFullPropertyCodeRefactoringProvider.cs | 20 +++++++++++++++---- .../Core/Portable/FeaturesResources.resx | 3 +++ .../Portable/xlf/FeaturesResources.cs.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.de.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.es.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.fr.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.it.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.ja.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.ko.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.pl.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.pt-BR.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.ru.xlf | 5 +++++ .../Portable/xlf/FeaturesResources.tr.xlf | 5 +++++ .../xlf/FeaturesResources.zh-Hans.xlf | 5 +++++ .../xlf/FeaturesResources.zh-Hant.xlf | 5 +++++ ...lBasicConvertAutoPropertyToFullProperty.vb | 4 ++++ .../Services/SyntaxFacts/CSharpSyntaxFacts.cs | 4 ++++ .../Core/Services/SyntaxFacts/ISyntaxFacts.cs | 11 +++++----- .../SyntaxFacts/VisualBasicSyntaxFacts.vb | 4 ++++ 25 files changed, 123 insertions(+), 33 deletions(-) diff --git a/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs index f233637622a7f..ea3ff1d9974e4 100644 --- a/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs +++ b/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs @@ -8,6 +8,7 @@ using System.Linq; using System.Threading; using Microsoft.CodeAnalysis.CSharp.Extensions; +using Microsoft.CodeAnalysis.CSharp.Shared.Extensions; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Shared.Extensions; @@ -41,23 +42,9 @@ protected override bool SupportsReadOnlyProperties(Compilation compilation) protected override bool SupportsPropertyInitializer(Compilation compilation) => compilation.LanguageVersion() >= LanguageVersion.CSharp6; - protected override bool SupportsFieldExpression(Compilation compilation) - => compilation.LanguageVersion() >= LanguageVersion.Preview; - protected override ExpressionSyntax? GetFieldInitializer(VariableDeclaratorSyntax variable, CancellationToken cancellationToken) => variable.Initializer?.Value; - protected override bool ContainsFieldExpression(PropertyDeclarationSyntax propertyDeclaration, CancellationToken cancellationToken) - { - foreach (var node in propertyDeclaration.DescendantNodes()) - { - if (node.IsKind(SyntaxKind.FieldExpression)) - return true; - } - - return false; - } - protected override void RecordIneligibleFieldLocations( HashSet fieldNames, ConcurrentDictionary> ineligibleFieldUsageIfOutsideProperty, diff --git a/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs b/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs index 660f93366a5e9..bde87d66bf769 100644 --- a/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs +++ b/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs @@ -4,6 +4,7 @@ using System.Threading.Tasks; using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Shared.Extensions; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; using Xunit; @@ -14,7 +15,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseAutoProperty; public sealed partial class UseAutoPropertyTests { private static readonly ParseOptions CSharp13 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp13); - private static readonly ParseOptions CSharp14 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Preview); + private static readonly ParseOptions CSharp14 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersionExtensions.CSharpNext); [Fact] public async Task TestNotInCSharp13() diff --git a/src/Analyzers/CSharp/Tests/UseImplicitlyTypedLambdaExpression/UseImplicitlyTypedLambdaExpressionTests.cs b/src/Analyzers/CSharp/Tests/UseImplicitlyTypedLambdaExpression/UseImplicitlyTypedLambdaExpressionTests.cs index 437372cd52917..ea122efc4460d 100644 --- a/src/Analyzers/CSharp/Tests/UseImplicitlyTypedLambdaExpression/UseImplicitlyTypedLambdaExpressionTests.cs +++ b/src/Analyzers/CSharp/Tests/UseImplicitlyTypedLambdaExpression/UseImplicitlyTypedLambdaExpressionTests.cs @@ -4,6 +4,7 @@ using System.Threading.Tasks; using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Shared.Extensions; using Microsoft.CodeAnalysis.CSharp.UseImplicitlyTypedLambdaExpression; using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Test.Utilities; @@ -18,7 +19,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseImplicitlyTypedLambd [Trait(Traits.Feature, Traits.Features.CodeActionsUseImplicitObjectCreation)] public sealed class UseImplicitlyTypedLambdaExpressionTests { - private static readonly LanguageVersion CSharp14 = LanguageVersion.Preview; + private static readonly LanguageVersion CSharp14 = LanguageVersionExtensions.CSharpNext; [Fact] public async Task TestAssignedToObject() diff --git a/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs index 50584ae2493dc..ac98e5754cbaf 100644 --- a/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs +++ b/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs @@ -82,9 +82,6 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory() protected abstract bool SupportsReadOnlyProperties(Compilation compilation); protected abstract bool SupportsPropertyInitializer(Compilation compilation); - protected abstract bool SupportsFieldExpression(Compilation compilation); - - protected abstract bool ContainsFieldExpression(TPropertyDeclaration propertyDeclaration, CancellationToken cancellationToken); protected abstract TExpression? GetFieldInitializer(TVariableDeclarator variable, CancellationToken cancellationToken); protected abstract TExpression? GetGetterExpression(IMethodSymbol getMethod, CancellationToken cancellationToken); @@ -265,7 +262,7 @@ private AccessedFields GetGetterFields( if (trivialFieldExpression != null) return new(CheckFieldAccessExpression(semanticModel, trivialFieldExpression, fieldNames, cancellationToken)); - if (!this.SupportsFieldExpression(semanticModel.Compilation)) + if (!this.SyntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options)) return AccessedFields.Empty; using var _ = PooledHashSet.GetInstance(out var set); @@ -281,7 +278,7 @@ private AccessedFields GetSetterFields( if (trivialFieldExpression != null) return new(CheckFieldAccessExpression(semanticModel, trivialFieldExpression, fieldNames, cancellationToken)); - if (!this.SupportsFieldExpression(semanticModel.Compilation)) + if (!this.SyntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options)) return AccessedFields.Empty; using var _ = PooledHashSet.GetInstance(out var set); @@ -381,8 +378,11 @@ private void AnalyzePropertyDeclaration( return; // If the property already contains a `field` expression, then we can't do anything more here. - if (SupportsFieldExpression(compilation) && ContainsFieldExpression(propertyDeclaration, cancellationToken)) + if (this.SyntaxFacts.SupportsFieldExpression(propertyDeclaration.SyntaxTree.Options) && + propertyDeclaration.DescendantNodes().Any(this.SyntaxFacts.IsFieldExpression)) + { return; + } var getterFields = GetGetterFields(semanticModel, property.GetMethod, fieldNames, cancellationToken); getterFields = getterFields.Where( @@ -550,7 +550,7 @@ private void Process( // All the usages were inside the property. This is ok if we support the `field` keyword as those // usages will be updated to that form. - if (!this.SupportsFieldExpression(context.Compilation)) + if (!this.SyntaxFacts.SupportsFieldExpression(result.PropertyDeclaration.SyntaxTree.Options)) continue; } diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 97d5afdd92d3c..6723d04793e86 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -154,4 +154,11 @@ protected override SyntaxNode GetInitializerValue(SyntaxNode property) protected override SyntaxNode GetPropertyWithoutInitializer(SyntaxNode property) => ((PropertyDeclarationSyntax)property).WithInitializer(null); + + protected override async Task ExpandToFieldPropertyAsync( + Document document, PropertyDeclarationSyntax property, CancellationToken cancellationToken) + { + var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); + + } } diff --git a/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs b/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs index fc758d25c61b1..d782c5507d4aa 100644 --- a/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs +++ b/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs @@ -6,6 +6,7 @@ using Microsoft.CodeAnalysis.CodeRefactorings; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.ConvertAutoPropertyToFullProperty; +using Microsoft.CodeAnalysis.CSharp.Shared.Extensions; using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; @@ -16,7 +17,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertAutoPropertyToFu [Trait(Traits.Feature, Traits.Features.ConvertAutoPropertyToFullProperty)] public sealed partial class ConvertAutoPropertyToFullPropertyTests : AbstractCSharpCodeActionTest_NoEditor { - private static readonly CSharpParseOptions s_preview = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Preview); + private static readonly CSharpParseOptions s_preview = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersionExtensions.CSharpNext); protected override CodeRefactoringProvider CreateCodeRefactoringProvider(TestWorkspace workspace, TestParameters parameters) => new CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider(); diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 6001d0c2cc020..de3758f014d02 100644 --- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -11,6 +11,7 @@ using Microsoft.CodeAnalysis.CodeRefactorings; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Formatting; +using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.Shared.Extensions; using Roslyn.Utilities; @@ -28,6 +29,7 @@ protected abstract (SyntaxNode newGetAccessor, SyntaxNode? newSetAccessor) GetNe protected abstract SyntaxNode GetInitializerValue(SyntaxNode property); protected abstract SyntaxNode ConvertPropertyToExpressionBodyIfDesired(TCodeGenerationContextInfo info, SyntaxNode fullProperty); protected abstract SyntaxNode GetTypeBlock(SyntaxNode syntaxNode); + protected abstract Task ExpandToFieldPropertyAsync(Document document, TPropertyDeclarationNode property, CancellationToken cancellationToken); public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { @@ -45,12 +47,22 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte if (!IsValidAutoProperty(propertySymbol)) return; - context.RegisterRefactoring( - CodeAction.Create( + context.RegisterRefactoring(CodeAction.Create( FeaturesResources.Convert_to_full_property, - cancellationToken => ExpandToFullPropertyAsync(document, property, propertySymbol, root, cancellationToken), + cancellationToken => ExpandToFullPropertyAsync(document, property, propertySymbol, cancellationToken), nameof(FeaturesResources.Convert_to_full_property)), property.Span); + + var syntaxFacts = document.GetRequiredLanguageService(); + if (syntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options) && + !property.DescendantNodes().Any(syntaxFacts.IsFieldExpression)) + { + context.RegisterRefactoring(CodeAction.Create( + FeaturesResources.Convert_to_field_property, + cancellationToken => ExpandToFieldPropertyAsync(document, property, cancellationToken), + nameof(FeaturesResources.Convert_to_field_property)), + property.Span); + } } internal static bool IsValidAutoProperty(IPropertySymbol propertySymbol) @@ -73,11 +85,11 @@ private async Task ExpandToFullPropertyAsync( Document document, TPropertyDeclarationNode property, IPropertySymbol propertySymbol, - SyntaxNode root, CancellationToken cancellationToken) { Contract.ThrowIfNull(document.DocumentState.ParseOptions); + var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var editor = new SyntaxEditor(root, document.Project.Solution.Services); var generator = editor.Generator; var info = (TCodeGenerationContextInfo)await document.GetCodeGenerationInfoAsync(CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false); diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx index d335bd56d7da9..533d925fc8586 100644 --- a/src/Features/Core/Portable/FeaturesResources.resx +++ b/src/Features/Core/Portable/FeaturesResources.resx @@ -3201,4 +3201,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of No valid statement range to extract + + Convert to 'field' property + \ No newline at end of file diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf index 9834783b76e7e..771c09b2d5150 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf @@ -560,6 +560,11 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn Převést číslo + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Převést na LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf index a391220d79418..14ad8c4e5645a 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf @@ -560,6 +560,11 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d Zahl konvertieren + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ In LINQ konvertieren diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf index 650833edcb06e..ed8409706554a 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf @@ -560,6 +560,11 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa Convertir número + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Convertir a LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf index 7f293261e1089..8c14d7db3d734 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf @@ -560,6 +560,11 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai Convertir un numéro + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Convertir en LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf index 1bbd3b65f2cb1..5a0a21afb7336 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf @@ -560,6 +560,11 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa Converti numero + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Converti in LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf index 71c1758ed1c58..8e0f632bd6603 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf @@ -560,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 数値の変換 + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ LINQ に変換 diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf index ecdf5d6fd26a9..e0130fb75b76b 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf @@ -560,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 숫자 변환 + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ LINQ로 변환 diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf index e0cfca5c78eab..3c63b284c70f5 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf @@ -560,6 +560,11 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k Konwertuj liczbę + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Konwertuj na składnię LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf index df56fda2243d2..21cb6d48c5cee 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf @@ -560,6 +560,11 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess Converter número + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Converter para LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf index be341769892e1..21a73cf6bc751 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf @@ -560,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Преобразовать число + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ Преобразовать в LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf index f35b8034505de..cbb524b4d2a02 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf @@ -560,6 +560,11 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be Sayıyı dönüştür + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ LINQ to dönüştürme diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf index 0e36fce0e293d..914685393bf37 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf @@ -560,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 转换数字 + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ 转换为 LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf index bb342ea2e488f..50bad32012da7 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf @@ -560,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 轉換號碼 + + Convert to 'field' property + Convert to 'field' property + + Convert to LINQ 轉換至 LINQ diff --git a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb index 3572c389d45f7..1712b8a46144e 100644 --- a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb +++ b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb @@ -86,5 +86,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty Protected Overrides Function GetTypeBlock(syntaxNode As SyntaxNode) As SyntaxNode Return DirectCast(syntaxNode, TypeStatementSyntax).Parent End Function + + Protected Overrides Function ExpandToFieldPropertyAsync(document As Document, [property] As PropertyStatementSyntax, cancellationToken As CancellationToken) As Task(Of Document) + Throw ExceptionUtilities.Unreachable() + End Function End Class End Namespace diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs index bad510b09163a..360493f97d2ec 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs @@ -13,6 +13,7 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Extensions; using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery; +using Microsoft.CodeAnalysis.CSharp.Shared.Extensions; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.PooledObjects; @@ -76,6 +77,9 @@ public bool SupportsCollectionExpressionNaturalType(ParseOptions options) public bool SupportsImplicitImplementationOfNonPublicInterfaceMembers(ParseOptions options) => options.LanguageVersion() >= LanguageVersion.CSharp10; + public bool SupportsFieldExpression(ParseOptions options) + => options.LanguageVersion() >= LanguageVersionExtensions.CSharpNext; + public SyntaxToken ParseToken(string text) => SyntaxFactory.ParseToken(text); diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs index 511e68649d0fe..e0abf008de631 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs @@ -91,18 +91,19 @@ internal interface ISyntaxFacts ISyntaxKinds SyntaxKinds { get; } + bool SupportsCollectionExpressionNaturalType(ParseOptions options); + bool SupportsConstantInterpolatedStrings(ParseOptions options); + bool SupportsFieldExpression(ParseOptions options); + bool SupportsImplicitImplementationOfNonPublicInterfaceMembers(ParseOptions options); bool SupportsIndexingInitializer(ParseOptions options); + bool SupportsIsNotTypeExpression(ParseOptions options); bool SupportsLocalFunctionDeclaration(ParseOptions options); bool SupportsNotPattern(ParseOptions options); bool SupportsRecord(ParseOptions options); bool SupportsRecordStruct(ParseOptions options); - bool SupportsThrowExpression(ParseOptions options); bool SupportsTargetTypedConditionalExpression(ParseOptions options); - bool SupportsIsNotTypeExpression(ParseOptions options); - bool SupportsConstantInterpolatedStrings(ParseOptions options); + bool SupportsThrowExpression(ParseOptions options); bool SupportsTupleDeconstruction(ParseOptions options); - bool SupportsCollectionExpressionNaturalType(ParseOptions options); - bool SupportsImplicitImplementationOfNonPublicInterfaceMembers(ParseOptions options); SyntaxToken ParseToken(string text); SyntaxTriviaList ParseLeadingTrivia(string text); diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb index f5a6fee82047e..0c464486a45f4 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb @@ -84,6 +84,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageService Return True End Function + Public Function SupportsFieldExpression(options As ParseOptions) As Boolean Implements ISyntaxFacts.SupportsFieldExpression + Return False + End Function + Public Function ParseToken(text As String) As SyntaxToken Implements ISyntaxFacts.ParseToken Return SyntaxFactory.ParseToken(text, startStatement:=True) End Function From b80df36a0e7d8caa7d85711a05de9fe0341090f1 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 19:40:27 -0800 Subject: [PATCH 44/76] in progress --- ...tyToFullPropertyCodeRefactoringProvider.cs | 87 ++++++++++++++++--- ...tyToFullPropertyCodeRefactoringProvider.cs | 10 +-- ...lBasicConvertAutoPropertyToFullProperty.vb | 2 +- 3 files changed, 82 insertions(+), 17 deletions(-) diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 6723d04793e86..1ea822c4a6a05 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -24,6 +24,7 @@ namespace Microsoft.CodeAnalysis.CSharp.ConvertAutoPropertyToFullProperty; using static CSharpSyntaxTokens; +using static SyntaxFactory; [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.ConvertAutoPropertyToFullProperty), Shared] [method: ImportingConstructor] @@ -44,14 +45,19 @@ protected override async Task GetFieldNameAsync(Document document, IProp } protected override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors( - CSharpCodeGenerationContextInfo info, PropertyDeclarationSyntax property, - string fieldName, SyntaxGenerator generator, CancellationToken cancellationToken) + CSharpCodeGenerationContextInfo info, + PropertyDeclarationSyntax property, + string fieldName, + CancellationToken cancellationToken) { + return GetNewAccessors(info, property, fieldName.ToIdentifierName(), overwriteExistingBodies: false, cancellationToken); +#if false // C# might have trivia with the accessors that needs to be preserved. // so we will update the existing accessors instead of creating new ones var accessorListSyntax = property.AccessorList; var (getAccessor, setAccessor) = GetExistingAccessors(accessorListSyntax); + var generator = CSharpSyntaxGenerator.Instance; var fieldIdentifier = generator.IdentifierName(fieldName); var getAccessorStatement = generator.ReturnStatement(fieldIdentifier); var newGetter = GetUpdatedAccessor(getAccessor, getAccessorStatement); @@ -101,6 +107,70 @@ AccessorDeclarationSyntax ReplaceFieldExpression(AccessorDeclarationSyntax acces accessor.DescendantNodes().OfType(), (oldNode, _) => fieldIdentifier.WithTriviaFrom(oldNode)); } +#endif + } + + private (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors( + CSharpCodeGenerationContextInfo info, + PropertyDeclarationSyntax property, + ExpressionSyntax backingFieldExpression, + bool overwriteExistingBodies, + CancellationToken cancellationToken) + { + // C# might have trivia with the accessors that needs to be preserved. + // so we will update the existing accessors instead of creating new ones + var accessorListSyntax = property.AccessorList; + var (getAccessor, setAccessor) = GetExistingAccessors(accessorListSyntax); + + var getAccessorStatement = ReturnStatement(backingFieldExpression); + var newGetter = GetUpdatedAccessor(getAccessor, getAccessorStatement); + + var newSetter = setAccessor; + if (newSetter != null) + { + var setAccessorStatement = ExpressionStatement(AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + backingFieldExpression, + IdentifierName("value"))); + newSetter = GetUpdatedAccessor(setAccessor, setAccessorStatement); + } + + return (newGetter, newSetter); + + AccessorDeclarationSyntax GetUpdatedAccessor(AccessorDeclarationSyntax accessor, StatementSyntax statement) + { + if (!overwriteExistingBodies && (accessor.Body != null || accessor.ExpressionBody != null)) + return ReplaceFieldExpression(accessor); + + var newAccessor = AddStatement(accessor, statement); + var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor; + + var preference = info.Options.PreferExpressionBodiedAccessors.Value; + if (preference == ExpressionBodyPreference.Never) + { + return accessorDeclarationSyntax.WithSemicolonToken(default); + } + + if (!accessorDeclarationSyntax.Body.TryConvertToArrowExpressionBody( + accessorDeclarationSyntax.Kind(), info.LanguageVersion, preference, cancellationToken, + out var arrowExpression, out _)) + { + return accessorDeclarationSyntax.WithSemicolonToken(default); + } + + return accessorDeclarationSyntax + .WithExpressionBody(arrowExpression) + .WithBody(null) + .WithSemicolonToken(accessorDeclarationSyntax.SemicolonToken) + .WithAdditionalAnnotations(Formatter.Annotation); + } + + AccessorDeclarationSyntax ReplaceFieldExpression(AccessorDeclarationSyntax accessor) + { + return accessor.ReplaceNodes( + accessor.DescendantNodes().OfType(), + (oldNode, _) => backingFieldExpression.WithTriviaFrom(oldNode)); + } } private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax setAccessor) @@ -108,15 +178,12 @@ private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax => (accessorListSyntax.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration)), accessorListSyntax.Accessors.FirstOrDefault(a => a.Kind() is SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration)); - internal static SyntaxNode AddStatement(SyntaxNode accessor, SyntaxNode statement) + internal static SyntaxNode AddStatement(AccessorDeclarationSyntax accessor, StatementSyntax statement) { - var blockSyntax = SyntaxFactory.Block( - OpenBraceToken.WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed), - new SyntaxList((StatementSyntax)statement), - CloseBraceToken - .WithTrailingTrivia(((AccessorDeclarationSyntax)accessor).SemicolonToken.TrailingTrivia)); - - return ((AccessorDeclarationSyntax)accessor).WithBody(blockSyntax); + return accessor.WithBody(Block( + OpenBraceToken.WithLeadingTrivia(ElasticCarriageReturnLineFeed), + [statement], + CloseBraceToken.WithTrailingTrivia(accessor.SemicolonToken.TrailingTrivia))); } protected override SyntaxNode ConvertPropertyToExpressionBodyIfDesired( diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index de3758f014d02..f4193274c7451 100644 --- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -24,12 +24,11 @@ internal abstract class AbstractConvertAutoPropertyToFullPropertyCodeRefactoring { protected abstract Task GetFieldNameAsync(Document document, IPropertySymbol propertySymbol, CancellationToken cancellationToken); protected abstract (SyntaxNode newGetAccessor, SyntaxNode? newSetAccessor) GetNewAccessors( - TCodeGenerationContextInfo info, TPropertyDeclarationNode property, string fieldName, SyntaxGenerator generator, CancellationToken cancellationToken); + TCodeGenerationContextInfo info, TPropertyDeclarationNode property, string fieldName, CancellationToken cancellationToken); protected abstract SyntaxNode GetPropertyWithoutInitializer(SyntaxNode property); protected abstract SyntaxNode GetInitializerValue(SyntaxNode property); protected abstract SyntaxNode ConvertPropertyToExpressionBodyIfDesired(TCodeGenerationContextInfo info, SyntaxNode fullProperty); protected abstract SyntaxNode GetTypeBlock(SyntaxNode syntaxNode); - protected abstract Task ExpandToFieldPropertyAsync(Document document, TPropertyDeclarationNode property, CancellationToken cancellationToken); public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { @@ -59,7 +58,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte { context.RegisterRefactoring(CodeAction.Create( FeaturesResources.Convert_to_field_property, - cancellationToken => ExpandToFieldPropertyAsync(document, property, cancellationToken), + cancellationToken => ExpandToFieldPropertyAsync(document, property, propertySymbol, cancellationToken), nameof(FeaturesResources.Convert_to_field_property)), property.Span); } @@ -91,14 +90,13 @@ private async Task ExpandToFullPropertyAsync( var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var editor = new SyntaxEditor(root, document.Project.Solution.Services); - var generator = editor.Generator; var info = (TCodeGenerationContextInfo)await document.GetCodeGenerationInfoAsync(CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false); // Create full property. If the auto property had an initial value // we need to remove it and later add it to the backing field var fieldName = await GetFieldNameAsync(document, propertySymbol, cancellationToken).ConfigureAwait(false); - var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, fieldName, generator, cancellationToken); - var fullProperty = generator + var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, fieldName, cancellationToken); + var fullProperty = editor.Generator .WithAccessorDeclarations( GetPropertyWithoutInitializer(property), newSetAccessor == null diff --git a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb index 1712b8a46144e..1e69bdda2a876 100644 --- a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb +++ b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb @@ -36,9 +36,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty info As VisualBasicCodeGenerationContextInfo, propertySyntax As PropertyStatementSyntax, fieldName As String, - generator As SyntaxGenerator, cancellationToken As CancellationToken) As (newGetAccessor As SyntaxNode, newSetAccessor As SyntaxNode) + Dim generator = VisualBasicSyntaxGenerator.Instance Dim returnStatement = New SyntaxList(Of StatementSyntax)(DirectCast(generator.ReturnStatement( generator.IdentifierName(fieldName)), StatementSyntax)) Dim getAccessor As SyntaxNode = SyntaxFactory.GetAccessorBlock( From 5ec15ee9762e0cb2e2e65ec40235c2ca1a1dc7d9 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 19:50:01 -0800 Subject: [PATCH 45/76] in progress --- ...tyToFullPropertyCodeRefactoringProvider.cs | 69 +++---------------- ...tyToFullPropertyCodeRefactoringProvider.cs | 33 ++++++--- 2 files changed, 35 insertions(+), 67 deletions(-) diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 1ea822c4a6a05..dea65dc1a14d8 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -9,6 +9,7 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; +using Microsoft.CodeAnalysis.CodeGeneration; using Microsoft.CodeAnalysis.CodeRefactorings; using Microsoft.CodeAnalysis.CodeStyle; using Microsoft.CodeAnalysis.ConvertAutoPropertyToFullProperty; @@ -51,66 +52,9 @@ protected override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNew CancellationToken cancellationToken) { return GetNewAccessors(info, property, fieldName.ToIdentifierName(), overwriteExistingBodies: false, cancellationToken); -#if false - // C# might have trivia with the accessors that needs to be preserved. - // so we will update the existing accessors instead of creating new ones - var accessorListSyntax = property.AccessorList; - var (getAccessor, setAccessor) = GetExistingAccessors(accessorListSyntax); - - var generator = CSharpSyntaxGenerator.Instance; - var fieldIdentifier = generator.IdentifierName(fieldName); - var getAccessorStatement = generator.ReturnStatement(fieldIdentifier); - var newGetter = GetUpdatedAccessor(getAccessor, getAccessorStatement); - - var newSetter = setAccessor; - if (newSetter != null) - { - var setAccessorStatement = generator.ExpressionStatement(generator.AssignmentStatement( - fieldIdentifier, - generator.IdentifierName("value"))); - newSetter = GetUpdatedAccessor(setAccessor, setAccessorStatement); - } - - return (newGetter, newSetter); - - AccessorDeclarationSyntax GetUpdatedAccessor(AccessorDeclarationSyntax accessor, SyntaxNode statement) - { - if (accessor.Body != null || accessor.ExpressionBody != null) - return ReplaceFieldExpression(accessor); - - var newAccessor = AddStatement(accessor, statement); - var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor; - - var preference = info.Options.PreferExpressionBodiedAccessors.Value; - if (preference == ExpressionBodyPreference.Never) - { - return accessorDeclarationSyntax.WithSemicolonToken(default); - } - - if (!accessorDeclarationSyntax.Body.TryConvertToArrowExpressionBody( - accessorDeclarationSyntax.Kind(), info.LanguageVersion, preference, cancellationToken, - out var arrowExpression, out _)) - { - return accessorDeclarationSyntax.WithSemicolonToken(default); - } - - return accessorDeclarationSyntax - .WithExpressionBody(arrowExpression) - .WithBody(null) - .WithSemicolonToken(accessorDeclarationSyntax.SemicolonToken) - .WithAdditionalAnnotations(Formatter.Annotation); - } - - AccessorDeclarationSyntax ReplaceFieldExpression(AccessorDeclarationSyntax accessor) - { - return accessor.ReplaceNodes( - accessor.DescendantNodes().OfType(), - (oldNode, _) => fieldIdentifier.WithTriviaFrom(oldNode)); - } -#endif } - private (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors( + private static (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors( CSharpCodeGenerationContextInfo info, PropertyDeclarationSyntax property, ExpressionSyntax backingFieldExpression, @@ -225,7 +169,16 @@ protected override SyntaxNode GetPropertyWithoutInitializer(SyntaxNode property) protected override async Task ExpandToFieldPropertyAsync( Document document, PropertyDeclarationSyntax property, CancellationToken cancellationToken) { + var info = (CSharpCodeGenerationContextInfo)await document.GetCodeGenerationInfoAsync(CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false); + var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); + // Update the getter/setter to reference 'field'. + var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, FieldExpression(), overwriteExistingBodies: true, cancellationToken); + + var finalProperty = CreateFinalProperty(document, property, info, newGetAccessor, newSetAccessor); + var finalRoot = root.ReplaceNode(property, finalProperty); + + return document.WithSyntaxRoot(finalRoot); } } diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index f4193274c7451..af607b21089cc 100644 --- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -29,6 +29,7 @@ protected abstract (SyntaxNode newGetAccessor, SyntaxNode? newSetAccessor) GetNe protected abstract SyntaxNode GetInitializerValue(SyntaxNode property); protected abstract SyntaxNode ConvertPropertyToExpressionBodyIfDesired(TCodeGenerationContextInfo info, SyntaxNode fullProperty); protected abstract SyntaxNode GetTypeBlock(SyntaxNode syntaxNode); + protected abstract Task ExpandToFieldPropertyAsync(Document document, TPropertyDeclarationNode property, CancellationToken cancellationToken); public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { @@ -58,7 +59,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte { context.RegisterRefactoring(CodeAction.Create( FeaturesResources.Convert_to_field_property, - cancellationToken => ExpandToFieldPropertyAsync(document, property, propertySymbol, cancellationToken), + cancellationToken => ExpandToFieldPropertyAsync(document, property, cancellationToken), nameof(FeaturesResources.Convert_to_field_property)), property.Span); } @@ -90,20 +91,14 @@ private async Task ExpandToFullPropertyAsync( var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var editor = new SyntaxEditor(root, document.Project.Solution.Services); + var generator = editor.Generator; var info = (TCodeGenerationContextInfo)await document.GetCodeGenerationInfoAsync(CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false); // Create full property. If the auto property had an initial value // we need to remove it and later add it to the backing field var fieldName = await GetFieldNameAsync(document, propertySymbol, cancellationToken).ConfigureAwait(false); var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, fieldName, cancellationToken); - var fullProperty = editor.Generator - .WithAccessorDeclarations( - GetPropertyWithoutInitializer(property), - newSetAccessor == null - ? [newGetAccessor] - : [newGetAccessor, newSetAccessor]) - .WithLeadingTrivia(property.GetLeadingTrivia()); - fullProperty = ConvertPropertyToExpressionBodyIfDesired(info, fullProperty); + var fullProperty = CreateFinalProperty(document, property, info, newGetAccessor, newSetAccessor); editor.ReplaceNode(property, fullProperty.WithAdditionalAnnotations(Formatter.Annotation)); @@ -129,4 +124,24 @@ private async Task ExpandToFullPropertyAsync( var newRoot = editor.GetChangedRoot(); return document.WithSyntaxRoot(newRoot); } + + protected SyntaxNode CreateFinalProperty( + Document document, + TPropertyDeclarationNode property, + TCodeGenerationContextInfo info, + SyntaxNode newGetAccessor, + SyntaxNode? newSetAccessor) + { + var generator = document.GetRequiredLanguageService(); + + var fullProperty = generator + .WithAccessorDeclarations( + GetPropertyWithoutInitializer(property), + newSetAccessor == null + ? [newGetAccessor] + : [newGetAccessor, newSetAccessor]) + .WithLeadingTrivia(property.GetLeadingTrivia()); + fullProperty = ConvertPropertyToExpressionBodyIfDesired(info, fullProperty); + return fullProperty; + } } From c28f5ec5ed17e14b5bd1747dc2609ab4ae8a8c56 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 19:59:19 -0800 Subject: [PATCH 46/76] Support converting to a field backed property --- .../VisualBasicUseAutoPropertyAnalyzer.vb | 9 ---- ...tyToFullPropertyCodeRefactoringProvider.cs | 10 ++-- .../ConvertAutoPropertyToFullPropertyTests.cs | 53 ++++++++++++++++++- ...tyToFullPropertyCodeRefactoringProvider.cs | 7 +-- 4 files changed, 60 insertions(+), 19 deletions(-) diff --git a/src/Analyzers/VisualBasic/Analyzers/UseAutoProperty/VisualBasicUseAutoPropertyAnalyzer.vb b/src/Analyzers/VisualBasic/Analyzers/UseAutoProperty/VisualBasicUseAutoPropertyAnalyzer.vb index a11a47261b69b..ce00c2434f568 100644 --- a/src/Analyzers/VisualBasic/Analyzers/UseAutoProperty/VisualBasicUseAutoPropertyAnalyzer.vb +++ b/src/Analyzers/VisualBasic/Analyzers/UseAutoProperty/VisualBasicUseAutoPropertyAnalyzer.vb @@ -34,18 +34,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseAutoProperty Return DirectCast(compilation, VisualBasicCompilation).LanguageVersion >= LanguageVersion.VisualBasic10 End Function - Protected Overrides Function SupportsFieldExpression(compilation As Compilation) As Boolean - ' 'field' keyword not supported in VB. - Return False - End Function - Protected Overrides ReadOnly Property CanExplicitInterfaceImplementationsBeFixed As Boolean = True Protected Overrides ReadOnly Property SupportsFieldAttributesOnProperties As Boolean = False - Protected Overrides Function ContainsFieldExpression(propertyDeclaration As PropertyBlockSyntax, cancellationToken As CancellationToken) As Boolean - Return False - End Function - Protected Overrides Sub RecordIneligibleFieldLocations( fieldNames As HashSet(Of String), ineligibleFieldUsageIfOutsideProperty As ConcurrentDictionary(Of IFieldSymbol, ConcurrentSet(Of SyntaxNode)), diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index dea65dc1a14d8..8c0736fe10761 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -51,14 +51,14 @@ protected override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNew string fieldName, CancellationToken cancellationToken) { - return GetNewAccessors(info, property, fieldName.ToIdentifierName(), overwriteExistingBodies: false, cancellationToken); + // Replace the bodies with bodies that reference the new field name. + return GetNewAccessors(info, property, fieldName.ToIdentifierName(), cancellationToken); } private static (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors( CSharpCodeGenerationContextInfo info, PropertyDeclarationSyntax property, ExpressionSyntax backingFieldExpression, - bool overwriteExistingBodies, CancellationToken cancellationToken) { // C# might have trivia with the accessors that needs to be preserved. @@ -83,7 +83,7 @@ private static (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAcce AccessorDeclarationSyntax GetUpdatedAccessor(AccessorDeclarationSyntax accessor, StatementSyntax statement) { - if (!overwriteExistingBodies && (accessor.Body != null || accessor.ExpressionBody != null)) + if (accessor.Body != null || accessor.ExpressionBody != null) return ReplaceFieldExpression(accessor); var newAccessor = AddStatement(accessor, statement); @@ -173,8 +173,8 @@ protected override async Task ExpandToFieldPropertyAsync( var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); - // Update the getter/setter to reference 'field'. - var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, FieldExpression(), overwriteExistingBodies: true, cancellationToken); + // Update the getter/setter to reference the 'field' expression instead. + var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, FieldExpression(), cancellationToken); var finalProperty = CreateFinalProperty(document, property, info, newGetAccessor, newSetAccessor); var finalRoot = root.ReplaceNode(property, finalProperty); diff --git a/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs b/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs index d782c5507d4aa..111cea0267bfa 100644 --- a/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs +++ b/src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests.cs @@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertAutoPropertyToFu [Trait(Traits.Feature, Traits.Features.ConvertAutoPropertyToFullProperty)] public sealed partial class ConvertAutoPropertyToFullPropertyTests : AbstractCSharpCodeActionTest_NoEditor { - private static readonly CSharpParseOptions s_preview = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersionExtensions.CSharpNext); + private static readonly CSharpParseOptions CSharp14 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersionExtensions.CSharpNext); protected override CodeRefactoringProvider CreateCodeRefactoringProvider(TestWorkspace workspace, TestParameters parameters) => new CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider(); @@ -763,6 +763,25 @@ class TestClass await TestInRegularAndScriptAsync(text, expected, options: PreferExpressionBodiesOnAccessorsAndMethods); } + [Fact] + public async Task GetterOnlyExpressionBodies_Field() + { + var text = """ + class TestClass + { + public int G[||]oo { get;} + } + """; + var expected = """ + class TestClass + { + public int Goo => field; + } + """; + await TestInRegularAndScriptAsync( + text, expected, options: PreferExpressionBodiesOnAccessorsAndMethods, index: 1, parseOptions: CSharp14); + } + [Fact] public async Task SetterOnly() { @@ -1393,6 +1412,36 @@ int [||]P void M(int i) { } } """, - parseOptions: s_preview); + parseOptions: CSharp14); + } + + [Theory] + [InlineData("set"), InlineData("init")] + [WorkItem("https://github.com/dotnet/roslyn/issues/76899")] + public async Task ProduceFieldBackedProperty(string setter) + { + var text = $$""" + class TestClass + { + public int G[||]oo { get; {{setter}}; } + } + """; + var expected = $$""" + class TestClass + { + public int Goo + { + get + { + return field; + } + {{setter}} + { + field = value; + } + } + } + """; + await TestInRegularAndScriptAsync(text, expected, options: DoNotPreferExpressionBodiedAccessors, index: 1, parseOptions: CSharp14); } } diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index af607b21089cc..72bbdfc64c7ca 100644 --- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -98,9 +98,10 @@ private async Task ExpandToFullPropertyAsync( // we need to remove it and later add it to the backing field var fieldName = await GetFieldNameAsync(document, propertySymbol, cancellationToken).ConfigureAwait(false); var (newGetAccessor, newSetAccessor) = GetNewAccessors(info, property, fieldName, cancellationToken); - var fullProperty = CreateFinalProperty(document, property, info, newGetAccessor, newSetAccessor); - editor.ReplaceNode(property, fullProperty.WithAdditionalAnnotations(Formatter.Annotation)); + editor.ReplaceNode( + property, + CreateFinalProperty(document, property, info, newGetAccessor, newSetAccessor)); // add backing field, plus initializer if it exists var newField = CodeGenerationSymbolFactory.CreateFieldSymbol( @@ -142,6 +143,6 @@ protected SyntaxNode CreateFinalProperty( : [newGetAccessor, newSetAccessor]) .WithLeadingTrivia(property.GetLeadingTrivia()); fullProperty = ConvertPropertyToExpressionBodyIfDesired(info, fullProperty); - return fullProperty; + return fullProperty.WithAdditionalAnnotations(Formatter.Annotation); } } From b6dec2860ce11621d9ef4b8e8ef6e96a34e8e5f3 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 20:04:33 -0800 Subject: [PATCH 47/76] Add docs --- ...tConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 72bbdfc64c7ca..28576e44ae95f 100644 --- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -53,6 +53,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte nameof(FeaturesResources.Convert_to_full_property)), property.Span); + // If supported, offer to convert auto-prop to use 'field' instead. var syntaxFacts = document.GetRequiredLanguageService(); if (syntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options) && !property.DescendantNodes().Any(syntaxFacts.IsFieldExpression)) @@ -91,7 +92,6 @@ private async Task ExpandToFullPropertyAsync( var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var editor = new SyntaxEditor(root, document.Project.Solution.Services); - var generator = editor.Generator; var info = (TCodeGenerationContextInfo)await document.GetCodeGenerationInfoAsync(CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false); // Create full property. If the auto property had an initial value From 6645d874a93b6682f728313ba2b8cdc068466d52 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 20:13:18 -0800 Subject: [PATCH 48/76] Add teset cases --- .../UseAutoPropertyTests_Field.cs | 105 ++++++++++++++++++ 1 file changed, 105 insertions(+) diff --git a/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs b/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs index bde87d66bf769..50709fb52ee51 100644 --- a/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs +++ b/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs @@ -1602,4 +1602,109 @@ void M() } """, new TestParameters(parseOptions: CSharp14)); } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76901")] + public async Task TestReadAndWrite() + { + await TestInRegularAndScript1Async( + """ + class C + { + private int [|_g|]; + + public int CustomGetter + { + get => _g < 0 ? 0 : _g; // Synthesized return value + set => _g = value; + } + } + """, + """ + class C + { + public int CustomGetter + { + get => field < 0 ? 0 : field; // Synthesized return value + set; + } + } + """, new TestParameters(parseOptions: CSharp14)); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76901")] + public async Task TestContractCall() + { + await TestInRegularAndScript1Async( + """ + class C + { + private int [|_s|]; + + public int CustomSetter + { + get => _s; + set + { + Assumes.True(value >= 0); // Validation + _s = value; + } + } + } + """, + """ + class C + { + public int CustomSetter + { + get; + set + { + Assumes.True(value >= 0); // Validation + field = value; + } + } + } + """, new TestParameters(parseOptions: CSharp14)); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76901")] + public async Task TestDelegateInvoke() + { + await TestInRegularAndScript1Async( + """ + using System; + + class C + { + private int [|_s|]; + public event Action OnChanged; + + public int ObservableProp + { + get => _s; + set + { + _s = value; + OnChanged.Invoke(nameof(ObservableProp)); + } + } + } + """, + """ + class C + { + public event Action OnChanged; + + public int ObservableProp + { + get; + set + { + field = value; + OnChanged.Invoke(nameof(ObservableProp)); + } + } + } + """, new TestParameters(parseOptions: CSharp14)); + } } From ce0844d6be7f5f5656dbf04b39ee68d3b1758fed Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 20:16:31 -0800 Subject: [PATCH 49/76] inline --- .../UseAutoPropertyTests_Field.cs | 2 ++ ...pertyToFullPropertyCodeRefactoringProvider.cs | 16 ++++------------ 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs b/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs index 50709fb52ee51..24d1b83ee50e0 100644 --- a/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs +++ b/src/Analyzers/CSharp/Tests/UseAutoProperty/UseAutoPropertyTests_Field.cs @@ -1691,6 +1691,8 @@ public int ObservableProp } """, """ + using System; + class C { public event Action OnChanged; diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 8c0736fe10761..4bf72eff9a63a 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -86,14 +86,14 @@ AccessorDeclarationSyntax GetUpdatedAccessor(AccessorDeclarationSyntax accessor, if (accessor.Body != null || accessor.ExpressionBody != null) return ReplaceFieldExpression(accessor); - var newAccessor = AddStatement(accessor, statement); - var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor; + var accessorDeclarationSyntax = accessor.WithBody(Block( + OpenBraceToken.WithLeadingTrivia(ElasticCarriageReturnLineFeed), + [statement], + CloseBraceToken.WithTrailingTrivia(accessor.SemicolonToken.TrailingTrivia))); var preference = info.Options.PreferExpressionBodiedAccessors.Value; if (preference == ExpressionBodyPreference.Never) - { return accessorDeclarationSyntax.WithSemicolonToken(default); - } if (!accessorDeclarationSyntax.Body.TryConvertToArrowExpressionBody( accessorDeclarationSyntax.Kind(), info.LanguageVersion, preference, cancellationToken, @@ -122,14 +122,6 @@ private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax => (accessorListSyntax.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration)), accessorListSyntax.Accessors.FirstOrDefault(a => a.Kind() is SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration)); - internal static SyntaxNode AddStatement(AccessorDeclarationSyntax accessor, StatementSyntax statement) - { - return accessor.WithBody(Block( - OpenBraceToken.WithLeadingTrivia(ElasticCarriageReturnLineFeed), - [statement], - CloseBraceToken.WithTrailingTrivia(accessor.SemicolonToken.TrailingTrivia))); - } - protected override SyntaxNode ConvertPropertyToExpressionBodyIfDesired( CSharpCodeGenerationContextInfo info, SyntaxNode property) { From d8a4dc470bdab3e7e81002d0ae49d73a3d654461 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 20:20:09 -0800 Subject: [PATCH 50/76] Type safety --- ...toPropertyToFullPropertyCodeRefactoringProvider.cs | 8 ++++---- ...toPropertyToFullPropertyCodeRefactoringProvider.cs | 4 ++-- .../VisualBasicConvertAutoPropertyToFullProperty.vb | 11 +++++------ 3 files changed, 11 insertions(+), 12 deletions(-) diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 4bf72eff9a63a..c238e4b2dd533 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -152,11 +152,11 @@ protected override SyntaxNode ConvertPropertyToExpressionBodyIfDesired( protected override SyntaxNode GetTypeBlock(SyntaxNode syntaxNode) => syntaxNode; - protected override SyntaxNode GetInitializerValue(SyntaxNode property) - => ((PropertyDeclarationSyntax)property).Initializer?.Value; + protected override SyntaxNode GetInitializerValue(PropertyDeclarationSyntax property) + => property.Initializer?.Value; - protected override SyntaxNode GetPropertyWithoutInitializer(SyntaxNode property) - => ((PropertyDeclarationSyntax)property).WithInitializer(null); + protected override PropertyDeclarationSyntax GetPropertyWithoutInitializer(PropertyDeclarationSyntax property) + => property.WithInitializer(null); protected override async Task ExpandToFieldPropertyAsync( Document document, PropertyDeclarationSyntax property, CancellationToken cancellationToken) diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 28576e44ae95f..9fdb11ae24361 100644 --- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -25,8 +25,8 @@ internal abstract class AbstractConvertAutoPropertyToFullPropertyCodeRefactoring protected abstract Task GetFieldNameAsync(Document document, IPropertySymbol propertySymbol, CancellationToken cancellationToken); protected abstract (SyntaxNode newGetAccessor, SyntaxNode? newSetAccessor) GetNewAccessors( TCodeGenerationContextInfo info, TPropertyDeclarationNode property, string fieldName, CancellationToken cancellationToken); - protected abstract SyntaxNode GetPropertyWithoutInitializer(SyntaxNode property); - protected abstract SyntaxNode GetInitializerValue(SyntaxNode property); + protected abstract TPropertyDeclarationNode GetPropertyWithoutInitializer(TPropertyDeclarationNode property); + protected abstract SyntaxNode GetInitializerValue(TPropertyDeclarationNode property); protected abstract SyntaxNode ConvertPropertyToExpressionBodyIfDesired(TCodeGenerationContextInfo info, SyntaxNode fullProperty); protected abstract SyntaxNode GetTypeBlock(SyntaxNode syntaxNode); protected abstract Task ExpandToFieldPropertyAsync(Document document, TPropertyDeclarationNode property, CancellationToken cancellationToken); diff --git a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb index 1e69bdda2a876..c13c5244db136 100644 --- a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb +++ b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb @@ -7,13 +7,12 @@ Imports System.Diagnostics.CodeAnalysis Imports System.Threading Imports Microsoft.CodeAnalysis.CodeRefactorings Imports Microsoft.CodeAnalysis.ConvertAutoPropertyToFullProperty -Imports Microsoft.CodeAnalysis.Editing Imports Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty - Friend Class VisualBasicConvertAutoPropertyToFullPropertyCodeRefactoringProvider + Friend NotInheritable Class VisualBasicConvertAutoPropertyToFullPropertyCodeRefactoringProvider Inherits AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider(Of PropertyStatementSyntax, TypeBlockSyntax, VisualBasicCodeGenerationContextInfo) Private Const Underscore As String = "_" @@ -71,12 +70,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty Return False End Function - Protected Overrides Function GetPropertyWithoutInitializer(propertyNode As SyntaxNode) As SyntaxNode - Return DirectCast(propertyNode, PropertyStatementSyntax).WithInitializer(Nothing) + Protected Overrides Function GetPropertyWithoutInitializer(propertyNode As PropertyStatementSyntax) As PropertyStatementSyntax + Return propertyNode.WithInitializer(Nothing) End Function - Protected Overrides Function GetInitializerValue(propertyNode As SyntaxNode) As SyntaxNode - Return DirectCast(propertyNode, PropertyStatementSyntax).Initializer?.Value + Protected Overrides Function GetInitializerValue(propertyNode As PropertyStatementSyntax) As SyntaxNode + Return propertyNode.Initializer?.Value End Function Protected Overrides Function ConvertPropertyToExpressionBodyIfDesired(info As VisualBasicCodeGenerationContextInfo, propertyNode As SyntaxNode) As SyntaxNode From 8e914f954ceb956fca3cb6554a19a903abd6be5f Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 23:30:35 -0800 Subject: [PATCH 51/76] Speed up 'fix all' for 'use auto prop' by running in parallel --- .../UseAutoPropertyFixAllProvider.cs | 67 ++++++++++++++++--- 1 file changed, 56 insertions(+), 11 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 333052f575da3..a9aba0c43cd61 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -8,6 +8,8 @@ using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CodeFixesAndRefactorings; +using Microsoft.CodeAnalysis.Shared.Extensions; +using Microsoft.CodeAnalysis.Shared.Utilities; using Roslyn.Utilities; namespace Microsoft.CodeAnalysis.UseAutoProperty; @@ -34,23 +36,66 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP // effectively apply each fix one at a time, moving the solution forward each time. As we process each // diagnostic, we attempt to re-recover the field/property it was referring to in the original solution to // the current solution. + // + // Note: we can process each project in parallel. That's because all changes to a field/prop only impact + // the project they are in, and nothing beyond that. var originalSolution = originalContext.Solution; - var currentSolution = originalSolution; - foreach (var currentContext in contexts) - { - var documentToDiagnostics = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(currentContext).ConfigureAwait(false); - foreach (var (_, diagnostics) in documentToDiagnostics) + // Add a progress item for each context we need to process. + originalContext.Progress.AddItems(contexts.Length); + + var finalSolution = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( + contexts, + produceItems: async static (currentContext, callback, args, cancellationToken) => { - foreach (var diagnostic in diagnostics) + // Within a single context (a project) get all diagnostics, and then handle each diagnostic, one at + // a time, to get the final state of the project. + var (originalContext, provider) = args; + + // Complete a progress item as we finish each project. + using var _ = originalContext.Progress.ItemCompletedScope(); + + var originalSolution = originalContext.Solution; + var currentSolution = originalSolution; + + var documentToDiagnostics = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(currentContext).ConfigureAwait(false); + foreach (var (document, diagnostics) in documentToDiagnostics) + { + foreach (var diagnostic in diagnostics) + { + currentSolution = await provider.ProcessResultAsync( + originalSolution, currentSolution, diagnostic, cancellationToken).ConfigureAwait(false); + } + } + + // After we finish this context, report the changed documents to the consumeItems callback to process. + // This also lets us release all the forked solution info we created above. + foreach (var projectChanges in currentSolution.GetChanges(originalSolution).GetProjectChanges()) { - currentSolution = await provider.ProcessResultAsync( - originalSolution, currentSolution, diagnostic, cancellationToken).ConfigureAwait(false); + foreach (var changedDocumentId in projectChanges.GetChangedDocuments()) + { + var changedDocument = currentSolution.GetRequiredDocument(changedDocumentId); + var changedRoot = await changedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); + callback((changedDocumentId, changedRoot)); + } } - } - } + }, + consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => + { + var (originalContext, provider) = args; + var originalSolution = originalContext.Solution; + var currentSolution = originalSolution; + + // Take all the changed documents and update the final solution with them. + await foreach (var (documentId, newRoot) in documentsIdsAndNewRoots) + currentSolution = currentSolution.WithDocumentSyntaxRoot(documentId, newRoot); + + return currentSolution; + }, + args: (originalContext, provider), + cancellationToken).ConfigureAwait(false); - return currentSolution; + return finalSolution; } } } From db8d8e94847f350da8d5ef7506a2acf464c59f36 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 23:41:03 -0800 Subject: [PATCH 52/76] Lock string --- src/Features/Core/Portable/FeaturesResources.resx | 1 + src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.de.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.es.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.it.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf | 2 +- src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf | 2 +- 14 files changed, 14 insertions(+), 13 deletions(-) diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx index 533d925fc8586..48ea3a459fbec 100644 --- a/src/Features/Core/Portable/FeaturesResources.resx +++ b/src/Features/Core/Portable/FeaturesResources.resx @@ -3203,5 +3203,6 @@ Zero-width positive lookbehind assertions are typically used at the beginning of Convert to 'field' property + {Locked="field"} "field" is C# keyword and should not be localized. \ No newline at end of file diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf index 771c09b2d5150..abf7bf7c71c78 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf @@ -563,7 +563,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf index 14ad8c4e5645a..3f66f5c007bca 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf @@ -563,7 +563,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf index ed8409706554a..eaf7db275ce17 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf @@ -563,7 +563,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf index 8c14d7db3d734..cab7bba71c303 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf @@ -563,7 +563,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf index 5a0a21afb7336..76120583c5f41 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf @@ -563,7 +563,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf index 8e0f632bd6603..432a95cb4cbf9 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf @@ -563,7 +563,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf index e0130fb75b76b..355563e2fc89f 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf @@ -563,7 +563,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf index 3c63b284c70f5..aa4dadb24f4aa 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf @@ -563,7 +563,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf index 21cb6d48c5cee..c66c51062e0c4 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf @@ -563,7 +563,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf index 21a73cf6bc751..ab241c6db2a39 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf @@ -563,7 +563,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf index cbb524b4d2a02..ad6a0b9a037bb 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf @@ -563,7 +563,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf index 914685393bf37..7349eca4fb7b5 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf @@ -563,7 +563,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf index 50bad32012da7..8bc9eb2f3feab 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf @@ -563,7 +563,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Convert to 'field' property Convert to 'field' property - + {Locked="field"} "field" is C# keyword and should not be localized. Convert to LINQ From 8d77f7fbd2494f049b1ae00eb3ce0e4affbdd851 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 23 Jan 2025 23:46:28 -0800 Subject: [PATCH 53/76] Add error reporting --- .../AbstractUseAutoPropertyCodeFixProvider.cs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs b/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs index 52f02f4950ab6..841532b9e395e 100644 --- a/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. +using System; using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; @@ -13,6 +14,7 @@ using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Editing; +using Microsoft.CodeAnalysis.ErrorReporting; using Microsoft.CodeAnalysis.Formatting; using Microsoft.CodeAnalysis.Formatting.Rules; using Microsoft.CodeAnalysis.LanguageService; @@ -85,6 +87,19 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context) private async Task ProcessResultAsync( Solution originalSolution, Solution currentSolution, Diagnostic diagnostic, CancellationToken cancellationToken) + { + try + { + return await ProcessResultWorkerAsync(originalSolution, currentSolution, diagnostic, cancellationToken).ConfigureAwait(false); + } + catch (Exception ex) when (FatalError.ReportAndCatchUnlessCanceled(ex)) + { + return currentSolution; + } + } + + private async Task ProcessResultWorkerAsync( + Solution originalSolution, Solution currentSolution, Diagnostic diagnostic, CancellationToken cancellationToken) { var (field, property) = await MapDiagnosticToCurrentSolutionAsync( diagnostic, originalSolution, currentSolution, cancellationToken).ConfigureAwait(false); From 34a1414e6ba9368330e191f3b2909084d1e01da5 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:33:18 -0800 Subject: [PATCH 54/76] Update src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs --- .../Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index a9aba0c43cd61..2d993566df7db 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -59,7 +59,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP var currentSolution = originalSolution; var documentToDiagnostics = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(currentContext).ConfigureAwait(false); - foreach (var (document, diagnostics) in documentToDiagnostics) + foreach (var (_, diagnostics) in documentToDiagnostics) { foreach (var diagnostic in diagnostics) { From eb3b07f721d25965e601d3b3adc97a31993337c1 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:34:44 -0800 Subject: [PATCH 55/76] Apply suggestions from code review --- .../UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 2d993566df7db..e03c6054ee17d 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -82,9 +82,8 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP }, consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => { - var (originalContext, provider) = args; - var originalSolution = originalContext.Solution; - var currentSolution = originalSolution; + var (originalContext, _) = args; + var currentSolution = originalContext.Solution; // Take all the changed documents and update the final solution with them. await foreach (var (documentId, newRoot) in documentsIdsAndNewRoots) From e9da589c80f42b8ac07005ae976ef6a989d0d9d3 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:35:18 -0800 Subject: [PATCH 56/76] Apply suggestions from code review --- .../Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index e03c6054ee17d..5cb1a68be14a5 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -82,8 +82,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP }, consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => { - var (originalContext, _) = args; - var currentSolution = originalContext.Solution; + var currentSolution = args.originalContext.Solution; // Take all the changed documents and update the final solution with them. await foreach (var (documentId, newRoot) in documentsIdsAndNewRoots) From 15f06a237553878e219e526c4d9df90e596d6be4 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:36:57 -0800 Subject: [PATCH 57/76] Apply suggestions from code review --- .../Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 5cb1a68be14a5..6f934f7467c45 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -44,7 +44,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP // Add a progress item for each context we need to process. originalContext.Progress.AddItems(contexts.Length); - var finalSolution = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( + return await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( contexts, produceItems: async static (currentContext, callback, args, cancellationToken) => { @@ -93,7 +93,6 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP args: (originalContext, provider), cancellationToken).ConfigureAwait(false); - return finalSolution; } } } From 42a384fbbe5f1d1d5ee45328b7a385cd6c5a3cee Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:37:15 -0800 Subject: [PATCH 58/76] Update src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs --- .../Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 6f934f7467c45..d0c04b3e596e9 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -92,7 +92,6 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP }, args: (originalContext, provider), cancellationToken).ConfigureAwait(false); - } } } From 7f21472b97e3206667b0152136ffa05d49fb83b1 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:39:02 -0800 Subject: [PATCH 59/76] Tweak --- .../UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index a9aba0c43cd61..504336be7303c 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -30,7 +30,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP private async Task FixAllContextsHelperAsync(FixAllContext originalContext, ImmutableArray contexts) { - var cancellationToken = originalContext.CancellationToken; + var cancellationToken = ; // Very slow approach, but the only way we know how to do this correctly and without colliding edits. We // effectively apply each fix one at a time, moving the solution forward each time. As we process each @@ -44,7 +44,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP // Add a progress item for each context we need to process. originalContext.Progress.AddItems(contexts.Length); - var finalSolution = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( + return await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( contexts, produceItems: async static (currentContext, callback, args, cancellationToken) => { @@ -93,9 +93,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP return currentSolution; }, args: (originalContext, provider), - cancellationToken).ConfigureAwait(false); - - return finalSolution; + originalContext.CancellationToken).ConfigureAwait(false); } } } From b1799b741fb4265e38b21f5a90302a809fb0b89a Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:44:05 -0800 Subject: [PATCH 60/76] Simplify --- .../Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 82d7c727ad977..ca7789372a101 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -79,9 +79,8 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP }, consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => { + // Now take all the changed documents and produce the final solution with all of them combined. var currentSolution = args.originalContext.Solution; - - // Take all the changed documents and update the final solution with them. await foreach (var (documentId, newRoot) in documentsIdsAndNewRoots) currentSolution = currentSolution.WithDocumentSyntaxRoot(documentId, newRoot); From 8f4e4ffe6d77c0511bd27c2e282bea203eb93ce9 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:45:23 -0800 Subject: [PATCH 61/76] Simplify --- .../UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index ca7789372a101..9d5383c85f64e 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -67,14 +67,11 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP // After we finish this context, report the changed documents to the consumeItems callback to process. // This also lets us release all the forked solution info we created above. - foreach (var projectChanges in currentSolution.GetChanges(originalSolution).GetProjectChanges()) + foreach (var changedDocumentId in originalSolution.GetChangedDocuments(currentSolution)) { - foreach (var changedDocumentId in projectChanges.GetChangedDocuments()) - { - var changedDocument = currentSolution.GetRequiredDocument(changedDocumentId); - var changedRoot = await changedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); - callback((changedDocumentId, changedRoot)); - } + var changedDocument = currentSolution.GetRequiredDocument(changedDocumentId); + var changedRoot = await changedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); + callback((changedDocumentId, changedRoot)); } }, consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => From 877732369c53c57e06060ad10e565324c2dfe53b Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 00:47:20 -0800 Subject: [PATCH 62/76] Simplify --- .../Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 9d5383c85f64e..f5693e0a7f720 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; using Microsoft.CodeAnalysis.CodeActions; From 52f788aea0f5ff906d2a4d12694167042085a5a7 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 08:51:44 -0800 Subject: [PATCH 63/76] Use WithDocumentSyntaxRoots --- .../UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index f5693e0a7f720..168a05fbd9133 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -76,11 +76,8 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => { // Now take all the changed documents and produce the final solution with all of them combined. - var currentSolution = args.originalContext.Solution; - await foreach (var (documentId, newRoot) in documentsIdsAndNewRoots) - currentSolution = currentSolution.WithDocumentSyntaxRoot(documentId, newRoot); - - return currentSolution; + return args.originalContext.Solution.WithDocumentSyntaxRoots( + await documentsIdsAndNewRoots.ToImmutableArrayAsync(cancellationToken).ConfigureAwait(false)); }, args: (originalContext, provider), originalContext.CancellationToken).ConfigureAwait(false); From 658496603bed7b568673db151f89430ccd65db7b Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 09:21:26 -0800 Subject: [PATCH 64/76] Simplify --- .../UseAutoProperty/UseAutoPropertyFixAllProvider.cs | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs index 168a05fbd9133..122e14bff5003 100644 --- a/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs +++ b/src/Features/Core/Portable/UseAutoProperty/UseAutoPropertyFixAllProvider.cs @@ -40,7 +40,7 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP // Add a progress item for each context we need to process. originalContext.Progress.AddItems(contexts.Length); - return await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( + var documentsIdsAndNewRoots = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync( contexts, produceItems: async static (currentContext, callback, args, cancellationToken) => { @@ -73,14 +73,10 @@ private sealed class UseAutoPropertyFixAllProvider(TProvider provider) : FixAllP callback((changedDocumentId, changedRoot)); } }, - consumeItems: async static (documentsIdsAndNewRoots, args, cancellationToken) => - { - // Now take all the changed documents and produce the final solution with all of them combined. - return args.originalContext.Solution.WithDocumentSyntaxRoots( - await documentsIdsAndNewRoots.ToImmutableArrayAsync(cancellationToken).ConfigureAwait(false)); - }, args: (originalContext, provider), originalContext.CancellationToken).ConfigureAwait(false); + + return originalContext.Solution.WithDocumentSyntaxRoots(documentsIdsAndNewRoots); } } } From 0a0a3147a514258caad7343717514d2e4f88a811 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?= Date: Fri, 24 Jan 2025 09:55:55 -0800 Subject: [PATCH 65/76] Add back intenral EE APIs used by the debugger until the debugger switches to the new overloads (#76912) --- .../ExpressionCompiler/EvaluationContext.cs | 11 +++++++++++ .../Source/ExpressionCompiler/MetadataBlock.cs | 18 ++++++++---------- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs index 008ed555c6854..d074738506645 100644 --- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs +++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs @@ -91,6 +91,17 @@ internal static EvaluationContext CreateTypeContext( methodDebugInfo: MethodDebugInfo.None); } + // Used by VS debugger (/src/debugger/ProductionDebug/CodeAnalysis/CodeAnalysis/ExpressionEvaluator.cs) + internal static EvaluationContext CreateMethodContext( + ImmutableArray metadataBlocks, + object symReader, + Guid moduleId, + int methodToken, + int methodVersion, + uint ilOffset, + int localSignatureToken) + => CreateMethodContext(metadataBlocks, symReader, new ModuleId(moduleId, ""), methodToken, methodVersion, ilOffset, localSignatureToken); + /// /// Create a context for evaluating expressions within a method scope. /// diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs index afb5bde071fd5..8d5f4a684eb8b 100644 --- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs +++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/MetadataBlock.cs @@ -12,34 +12,32 @@ namespace Microsoft.CodeAnalysis.ExpressionEvaluator /// Module metadata block /// [DebuggerDisplay("{GetDebuggerDisplay(), nq}")] - internal readonly struct MetadataBlock : IEquatable + internal readonly struct MetadataBlock(ModuleId moduleId, Guid generationId, IntPtr pointer, int size) : IEquatable { /// /// Module id. /// - internal readonly ModuleId ModuleId; + internal readonly ModuleId ModuleId = moduleId; /// /// Module generation id. /// - internal readonly Guid GenerationId; + internal readonly Guid GenerationId = generationId; /// /// Pointer to memory block managed by the caller. /// - internal readonly IntPtr Pointer; + internal readonly IntPtr Pointer = pointer; /// /// Size of memory block. /// - internal readonly int Size; + internal readonly int Size = size; - internal MetadataBlock(ModuleId moduleId, Guid generationId, IntPtr pointer, int size) + // Used by VS debugger (/src/debugger/ProductionDebug/CodeAnalysis/CodeAnalysis/ExpressionEvaluator.cs) + internal MetadataBlock(Guid moduleId, Guid generationId, IntPtr pointer, int size) + : this(new ModuleId(moduleId, ""), generationId, pointer, size) { - ModuleId = moduleId; - GenerationId = generationId; - Pointer = pointer; - Size = size; } public bool Equals(MetadataBlock other) From 6010f5801aab22c65cd08ff50c3f40d3e2d32975 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 12:30:48 -0800 Subject: [PATCH 66/76] DO not offer to convert typeof to nameof on a generic type --- ...ConvertTypeOfToNameOfDiagnosticAnalyzer.cs | 3 --- ...ConvertTypeOfToNameOfDiagnosticAnalyzer.cs | 19 +++++++------------ ...ConvertTypeOfToNameOfDiagnosticAnalyzer.vb | 4 ---- 3 files changed, 7 insertions(+), 19 deletions(-) diff --git a/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs index 59a110ab2350b..8beb2a5c885fb 100644 --- a/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs +++ b/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs @@ -19,9 +19,6 @@ internal sealed class CSharpConvertTypeOfToNameOfDiagnosticAnalyzer() { private static readonly string s_title = CSharpAnalyzersResources.typeof_can_be_converted_to_nameof; - protected override bool SupportsUnboundGenerics(ParseOptions options) - => options.LanguageVersion().IsCSharp14OrAbove(); - protected override bool IsValidTypeofAction(OperationAnalysisContext context) { var node = context.Operation.Syntax; diff --git a/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs index 3e7664ae6bbdf..8db15069ba679 100644 --- a/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs +++ b/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs @@ -20,12 +20,8 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory() protected abstract bool IsValidTypeofAction(OperationAnalysisContext context); - protected abstract bool SupportsUnboundGenerics(ParseOptions options); - protected override void InitializeWorker(AnalysisContext context) - { - context.RegisterOperationAction(AnalyzeAction, OperationKind.TypeOf); - } + => context.RegisterOperationAction(AnalyzeAction, OperationKind.TypeOf); protected void AnalyzeAction(OperationAnalysisContext context) { @@ -47,7 +43,7 @@ protected void AnalyzeAction(OperationAnalysisContext context) } - private bool IsValidOperation(IOperation operation) + private static bool IsValidOperation(IOperation operation) { // Cast to a typeof operation & check parent is a property reference and member access var typeofOperation = (ITypeOfOperation)operation; @@ -69,11 +65,10 @@ private bool IsValidOperation(IOperation operation) if (typeofOperation.TypeOperand is not INamedTypeSymbol namedType) return false; - // Non-generic types are always convertible. typeof(X).Name can always be converted to nameof(X) - if (namedType.TypeArguments.Length == 0) - return true; - - // Generic types are convertible if the lang supports it. e.g. typeof(X).Name can be converted to nameof(X<>). - return SupportsUnboundGenerics(operation.Syntax.SyntaxTree.Options); + // Note: generic names like `typeof(List)` are not convertible (since the name will be List`1). However, + // it's fine if an outer part of the name is generic (like `typeof(List.Enumerator)`). as that will be + // convertible to `nameof(List<>.Enumerator)`. So we only need to check the type arguments directly on the type + // here, not on any containing types. + return namedType.TypeArguments.Length == 0; } } diff --git a/src/Analyzers/VisualBasic/Analyzers/ConvertTypeofToNameof/VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer.vb b/src/Analyzers/VisualBasic/Analyzers/ConvertTypeofToNameof/VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer.vb index 3f2a092381028..03d6de10849ac 100644 --- a/src/Analyzers/VisualBasic/Analyzers/ConvertTypeofToNameof/VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer.vb +++ b/src/Analyzers/VisualBasic/Analyzers/ConvertTypeofToNameof/VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer.vb @@ -18,10 +18,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertTypeOfToNameOf MyBase.New(s_title) End Sub - Protected Overrides Function SupportsUnboundGenerics(options As ParseOptions) As Boolean - Return False - End Function - Protected Overrides Function IsValidTypeofAction(context As OperationAnalysisContext) As Boolean Dim node = context.Operation.Syntax Dim compilation = context.Compilation From 6c7df49f485bdf5163bbc4e5f0ae21d1e12d854d Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 12:32:06 -0800 Subject: [PATCH 67/76] Update tests --- .../ConvertTypeOfToNameOfTests.cs | 24 ------------------- 1 file changed, 24 deletions(-) diff --git a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs index 0c357404fdc9b..587c000479209 100644 --- a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs +++ b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs @@ -272,18 +272,6 @@ void M() } } """, - FixedCode = """ - class Test - { - class Goo - { - void M() - { - _ = nameof(Goo<>); - } - } - } - """, LanguageVersion = CSharp14, }.RunAsync(); } @@ -326,18 +314,6 @@ void M() } } """, - FixedCode = """ - class Test - { - class Goo - { - void M() - { - _ = nameof(Goo<>); - } - } - } - """, LanguageVersion = CSharp14, }.RunAsync(); } From 7865b0cfb432cf0f2fa90a35b6ec24d118f9e2b5 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 24 Jan 2025 12:33:11 -0800 Subject: [PATCH 68/76] Update tests --- .../Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs index 587c000479209..73bb70b099749 100644 --- a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs +++ b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs @@ -267,7 +267,7 @@ class Goo { void M() { - _ = [|typeof(Goo).Name|]; + _ = typeof(Goo).Name; } } } @@ -309,7 +309,7 @@ class Goo { void M() { - _ = [|typeof(Goo<>).Name|]; + _ = typeof(Goo<>).Name; } } } From 09a5602928c03db5aa579b9fdadc179a69bfee2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?= Date: Fri, 24 Jan 2025 13:07:41 -0800 Subject: [PATCH 69/76] Add generated semantic search API list (#73966) --- ...GenerateFilteredReferenceAssembliesTask.cs | 86 +- .../ApiSet/Microsoft.CodeAnalysis.CSharp.txt | 10 +- .../ApiSet/Microsoft.CodeAnalysis.txt | 24 +- .../ApiSet/System.Runtime.txt | 19 +- .../Apis/Microsoft.CodeAnalysis.CSharp.txt | 6235 +++++++++++++ .../Apis/Microsoft.CodeAnalysis.txt | 4100 +++++++++ .../Apis/System.Collections.Immutable.txt | 799 ++ .../Apis/System.Collections.txt | 525 ++ .../ReferenceAssemblies/Apis/System.Linq.txt | 236 + .../Apis/System.Runtime.txt | 7757 +++++++++++++++++ .../Microsoft.CodeAnalysis.CSharp.txt | 6243 +++++++++++++ .../Baselines/Microsoft.CodeAnalysis.txt | 4333 +++++++++ .../System.Collections.Immutable.txt | 783 ++ .../Baselines/System.Collections.txt | 431 + .../Baselines/System.Linq.txt | 231 + .../Baselines/System.Runtime.txt | 7717 ++++++++++++++++ .../SemanticSearch.ReferenceAssemblies.csproj | 8 +- ...ateFilteredReferenceAssembliesTaskTests.cs | 7 +- 18 files changed, 39510 insertions(+), 34 deletions(-) create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt create mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt diff --git a/src/Tools/SemanticSearch/BuildTask/GenerateFilteredReferenceAssembliesTask.cs b/src/Tools/SemanticSearch/BuildTask/GenerateFilteredReferenceAssembliesTask.cs index 1bfd842325f35..6f394264544f9 100644 --- a/src/Tools/SemanticSearch/BuildTask/GenerateFilteredReferenceAssembliesTask.cs +++ b/src/Tools/SemanticSearch/BuildTask/GenerateFilteredReferenceAssembliesTask.cs @@ -13,6 +13,7 @@ using System.Reflection.Metadata.Ecma335; using System.Reflection.PortableExecutable; using System.Security.Cryptography; +using System.Text; using System.Text.RegularExpressions; using Microsoft.Build.Framework; using Microsoft.Build.Utilities; @@ -49,8 +50,7 @@ public sealed class GenerateFilteredReferenceAssembliesTask : Task \s* (?[+|-]?) ((?[A-Za-z]+):)? - (?[^#]*) - ([#].*)? + (?.*) $ """, RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace); @@ -63,6 +63,9 @@ public sealed class GenerateFilteredReferenceAssembliesTask : Task [Required] public string OutputDir { get; private set; } = null!; + [Required] + public string ApisDir { get; private set; } = null!; + public override bool Execute() { try @@ -106,6 +109,7 @@ internal void ExecuteImpl(IEnumerable<(string apiSpecPath, IReadOnlyList } var peImageBuffer = File.ReadAllBytes(originalReferencePath); + Rewrite(peImageBuffer, patterns.ToImmutableArray()); try @@ -116,8 +120,61 @@ internal void ExecuteImpl(IEnumerable<(string apiSpecPath, IReadOnlyList { // Another instance of the task might already be writing the content. Log.LogMessage($"Output file '{filteredReferencePath}' already exists."); + return; + } + + WriteApis(Path.Combine(ApisDir, assemblyName + ".txt"), peImageBuffer); + } + } + + internal void WriteApis(string outputFilePath, byte[] peImage) + { + using var readableStream = new MemoryStream(peImage, writable: false); + var metadataRef = MetadataReference.CreateFromStream(readableStream); + var compilation = CSharpCompilation.Create("Metadata", references: [metadataRef]); + + // Collect all externally accessible metadata member definitions: + var types = new List(); + var methods = new List(); + var fields = new List(); + GetAllMembers(compilation, types, methods, fields, + filter: s => s is { MetadataToken: not 0, DeclaredAccessibility: Accessibility.Public or Accessibility.Protected or Accessibility.ProtectedOrInternal }); + + var apis = new List(); + apis.AddRange(((IEnumerable)types).Concat(methods).Concat(fields).Select(GetDocumentationCommentSymbolName)); + + // Doc ids start with "X:" prefix, where X is member kind ('T', 'M' or 'F'): + apis.Sort(static (x, y) => x.AsSpan()[2..].CompareTo(y.AsSpan()[2..], StringComparison.Ordinal)); + + var newContent = "# Generated, do not update manually\r\n" + + string.Join("\r\n", apis); + + string currentContent; + try + { + currentContent = File.ReadAllText(outputFilePath, Encoding.UTF8); + } + catch (Exception) + { + currentContent = ""; + } + + if (currentContent != newContent) + { + try + { + File.WriteAllText(outputFilePath, newContent); + Log.LogMessage($"Baseline updated: '{outputFilePath}'"); + } + catch (Exception e) + { + Log.LogError($"Error updating baseline '{outputFilePath}': {e.Message}"); } } + else + { + Log.LogMessage($"Baseline not updated '{outputFilePath}'"); + } } internal static void ParseApiPatterns(IReadOnlyList lines, List<(string message, int line)> errors, List patterns) @@ -125,6 +182,10 @@ internal static void ParseApiPatterns(IReadOnlyList lines, List<(string for (var i = 0; i < lines.Count; i++) { var line = lines[i]; + if (line.TrimStart().StartsWith("#")) + { + continue; + } var match = s_lineSyntax.Match(line); if (!match.Success) @@ -197,7 +258,8 @@ internal static void GetAllMembers( Compilation compilation, List types, List methods, - List fields) + List fields, + Func filter) { Recurse(compilation.GlobalNamespace.GetMembers()); @@ -208,7 +270,7 @@ void Recurse(IEnumerable members) switch (member) { case INamedTypeSymbol type: - if (type.MetadataToken != 0) + if (filter(member)) { types.Add(type); Recurse(type.GetMembers()); @@ -216,14 +278,14 @@ void Recurse(IEnumerable members) break; case IMethodSymbol method: - if (method.MetadataToken != 0) + if (filter(member)) { methods.Add(method); } break; case IFieldSymbol field: - if (field.MetadataToken != 0) + if (filter(member)) { fields.Add(field); } @@ -237,12 +299,16 @@ void Recurse(IEnumerable members) } } - private static bool IsIncluded(ISymbol symbol, ImmutableArray patterns) + private static string GetDocumentationCommentSymbolName(ISymbol symbol) { var id = symbol.GetDocumentationCommentId(); Debug.Assert(id is [_, ':', ..]); - id = id[2..]; + return id[2..]; + } + private static bool IsIncluded(ISymbol symbol, ImmutableArray patterns) + { + var docName = GetDocumentationCommentSymbolName(symbol); var kind = GetKindFlags(symbol); // Type symbols areconsidered excluded by default. @@ -251,7 +317,7 @@ private static bool IsIncluded(ISymbol symbol, ImmutableArray patter foreach (var pattern in patterns) { - if ((pattern.SymbolKinds & kind) == kind && pattern.MetadataNamePattern.IsMatch(id)) + if ((pattern.SymbolKinds & kind) == kind && pattern.MetadataNamePattern.IsMatch(docName)) { isIncluded = pattern.IsIncluded; } @@ -285,7 +351,7 @@ internal static unsafe void Rewrite(byte[] peImage, ImmutableArray p var types = new List(); var methods = new List(); var fields = new List(); - GetAllMembers(compilation, types, methods, fields); + GetAllMembers(compilation, types, methods, fields, filter: s => s.MetadataToken != 0); // Update visibility flags: using var writableStream = new MemoryStream(peImage, writable: true); diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.CSharp.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.CSharp.txt index 5f282702bb03e..9c88fb1f47e2a 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.CSharp.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.CSharp.txt @@ -1 +1,9 @@ - \ No newline at end of file ++T:* +-T:Microsoft.CodeAnalysis.CSharp.CSharpCommandLine* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoKeyContainer* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoKeyFile* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoPublicKey* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyContainer* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyFile* +-M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoPublicKey* \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.txt index 6d657b0290b8a..ca701133245dc 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/Microsoft.CodeAnalysis.txt @@ -1,5 +1,23 @@ +T:* --M:Microsoft.CodeAnalysis.MetadataReference.CreateFromFile* +-M:Microsoft.CodeAnalysis.MetadataReference.Create* +-M:Microsoft.CodeAnalysis.AssemblyMetadata.Create* +-M:Microsoft.CodeAnalysis.ModuleMetadata.Create* -T:Microsoft.CodeAnalysis.FileSystemExtensions --T:Microsoft.CodeAnalysis.CommandLineParser --T:Microsoft.CodeAnalysis.DesktopStrongNameProvider \ No newline at end of file +-T:Microsoft.CodeAnalysis.CommandLine* +-T:Microsoft.CodeAnalysis.DesktopStrongNameProvider +-M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoKeyContainer* +-M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoKeyFile* +-M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoPublicKey* +-M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoKeyContainer* +-M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoKeyFile* +-M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoPublicKey* +-M:Microsoft.CodeAnalysis.Compilation.Emit* +-T:Microsoft.CodeAnalysis.Emit.* +-M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.#ctor* +-M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.#ctor* +-T:Microsoft.CodeAnalysis.RuleSet +-M:Microsoft.CodeAnalysis.SourceReferenceResolver.* +-M:Microsoft.CodeAnalysis.SourceFileResolver.* +-M:Microsoft.CodeAnalysis.XmlReferenceResolver.* +-M:Microsoft.CodeAnalysis.MetadataReferenceResolver.* +-M:Microsoft.CodeAnalysis.StrongNameProvider.* \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/System.Runtime.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/System.Runtime.txt index ce07ea552448d..6bd8294fcd0fe 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/System.Runtime.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/ApiSet/System.Runtime.txt @@ -3,6 +3,8 @@ -T:System.AppDomain* -T:System.AssemblyLoad* -T:System.AppContext +-T:System.CodeDom* +-T:System.Diagnostics.Debug.* -TM:System.Environment.* +M:System.Environment.get_CurrentManagedThreadId +M:System.Environment.get_NewLine @@ -10,6 +12,7 @@ -T:System.GC* -T:System.LoaderOptimization* -T:System.MarshalByRefObject +-T:System.ModuleHandle -T:System.MTAThreadAttribute -T:System.STAThreadAttribute -T:System.ThreadStaticAttribute @@ -19,27 +22,15 @@ +M:System.Type.Name +M:System.Type.FullName +M:System.Type.AssemblyQualifiedName --T:System.IO.* -+T:System.IO.BinaryReader -+T:System.IO.BinaryWriter -+T:System.IO.BufferedStream -+T:System.IO.EndOfStreamException -+T:System.IO.InvalidDataException -+T:System.IO.MemoryStream -+T:System.IO.Stream -+T:System.IO.StreamReader -+T:System.IO.StreamWriter -+T:System.IO.StringReader -+T:System.IO.StringWriter -+T:System.IO.TextReader -+T:System.IO.TextWriter +-T:System.IO.* -T:System.Net.* -T:System.Reflection.* -T:System.Resources.* -T:System.Runtime.* +T:System.Runtime.CompilerServices.* +-T:System.Runtime.CompilerServices.MethodImplOptions -T:System.Security.* diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt new file mode 100644 index 0000000000000..3075a24a86c70 --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt @@ -0,0 +1,6235 @@ +# Generated, do not update manually +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo) +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetHashCode +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_GetAwaiterMethod +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_GetResultMethod +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_IsCompletedProperty +Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_IsDynamic +Microsoft.CodeAnalysis.CSharp.CSharpCompilation +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference[]) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AppendDefaultVersionResource(System.IO.Stream) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Clone +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonAddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonClone +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateNativeIntegerTypeSymbol(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreatePreprocessingSymbol(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetEntryPoint(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetTypeByMetadataName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonRemoveAllSyntaxTrees +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonRemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithAssemblyName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithOptions(Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference},Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CreateScriptCompilation(System.String,Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference},Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions,Microsoft.CodeAnalysis.CSharp.CSharpCompilation,System.Type,System.Type) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDeclarationDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDirectiveReference(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetParseDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetUsedAssemblyReferences(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllReferences +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllSyntaxTrees +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(Microsoft.CodeAnalysis.MetadataReference[]) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.MetadataReference) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithAssemblyName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithOptions(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(Microsoft.CodeAnalysis.MetadataReference[]) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo) +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonAssembly +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonDynamicType +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonGlobalNamespace +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonObjectType +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonOptions +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonScriptClass +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonScriptGlobalsType +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonSourceModule +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonSyntaxTrees +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_DirectiveReferences +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_IsCaseSensitive +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_Language +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_LanguageVersion +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_Options +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_ReferencedAssemblyNames +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_ScriptCompilationInfo +Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_SyntaxTrees +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCheckOverflow(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithConcurrentBuild(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithDelaySign(System.Nullable{System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithDeterministic(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithFeatures(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMainTypeName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithModuleName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithOutputKind(Microsoft.CodeAnalysis.OutputKind) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithPlatform(Microsoft.CodeAnalysis.Platform) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithPublicSign(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithReportSuppressedDiagnostics(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithScriptClassName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.ComputeHashCode +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAllowUnsafe(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithConcurrentBuild(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDelaySign(System.Nullable{System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterministic(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMainTypeName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithModuleName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithNullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOverflowChecks(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPublicSign(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithReportSuppressedDiagnostics(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithScriptClassName(System.String) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.String[]) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithWarningLevel(System.Int32) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_AllowUnsafe +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_Language +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_NullableContextOptions +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_Usings +Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.set_NullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) +Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter +Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter.get_Instance +Microsoft.CodeAnalysis.CSharp.CSharpExtensions +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAliasInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAwaitExpressionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCollectionInitializerSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCompilationUnitRoot(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConstantValue(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetElementConversion(Microsoft.CodeAnalysis.Operations.ISpreadOperation) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetFirstDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInConversion(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetIndexerGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptableLocation(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptorMethod(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptsLocationAttributeSyntax(Microsoft.CodeAnalysis.CSharp.InterceptableLocation) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetLastDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetOutConversion(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetQueryClauseInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeAliasInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeConversion(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeTypeInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Insert(Microsoft.CodeAnalysis.SyntaxTokenList,System.Int32,Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsContextualKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsReservedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimStringLiteral(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SemanticModel@,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel@) +Microsoft.CodeAnalysis.CSharp.CSharpExtensions.VarianceKindFromToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions +Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions.Emit(Microsoft.CodeAnalysis.CSharp.CSharpCompilation,System.String,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver +Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(Microsoft.CodeAnalysis.IIncrementalGenerator[]) +Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(Microsoft.CodeAnalysis.ISourceGenerator[]) +Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ISourceGenerator},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) +Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ISourceGenerator},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider,Microsoft.CodeAnalysis.GeneratorDriverOptions) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.#ctor(Microsoft.CodeAnalysis.CSharp.LanguageVersion,Microsoft.CodeAnalysis.DocumentationMode,Microsoft.CodeAnalysis.SourceCodeKind,System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.GetHashCode +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.String[]) +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Default +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Features +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Language +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_LanguageVersion +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_PreprocessorSymbolNames +Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_SpecifiedLanguageVersion +Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo +Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.CSharp.CSharpCompilation) +Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.get_PreviousScriptCompilation +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.DeserializeFrom(System.IO.Stream,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.EquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindToken(System.Int32,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(System.Int32,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetDiagnostics +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLeadingTrivia +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLocation +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetTrailingTrivia +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertNodesInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertTokensInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.IsEquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Kind +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.NormalizeWhitespaceCore(System.String,System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.RemoveNodesCore(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceCore``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceNodeInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceTokenInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.get_Language +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.get_SyntaxTreeCore +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.#ctor(System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.Visit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFieldExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement``1(``0) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListSeparator(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList``1(Microsoft.CodeAnalysis.SyntaxList{``0}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.get_VisitIntoStructuredTrivia +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.#ctor +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CloneNodeAsRoot``1(``0) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean}) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetCompilationUnitRoot(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineMappings(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineVisibility(System.Int32,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRoot(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootCore(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.HasHiddenRegions +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRoot(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode@) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRootCore(Microsoft.CodeAnalysis.SyntaxNode@) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.get_Options +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.get_OptionsCore +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.#ctor +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.Visit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFieldExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1 +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.#ctor +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.Visit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFieldExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.#ctor(Microsoft.CodeAnalysis.SyntaxWalkerDepth) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitLeadingTrivia(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrailingTrivia(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.get_Depth +Microsoft.CodeAnalysis.CSharp.Conversion +Microsoft.CodeAnalysis.CSharp.Conversion.Equals(Microsoft.CodeAnalysis.CSharp.Conversion) +Microsoft.CodeAnalysis.CSharp.Conversion.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.Conversion.GetHashCode +Microsoft.CodeAnalysis.CSharp.Conversion.ToCommonConversion +Microsoft.CodeAnalysis.CSharp.Conversion.ToString +Microsoft.CodeAnalysis.CSharp.Conversion.get_ConstrainedToType +Microsoft.CodeAnalysis.CSharp.Conversion.get_Exists +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsAnonymousFunction +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsBoxing +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsCollectionExpression +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsConditionalExpression +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsConstantExpression +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsDefaultLiteral +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsDynamic +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsEnumeration +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsExplicit +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsIdentity +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsImplicit +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInlineArray +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsIntPtr +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInterpolatedString +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInterpolatedStringHandler +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsMethodGroup +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNullLiteral +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNullable +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNumeric +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsObjectCreation +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsPointer +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsReference +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsSpan +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsStackAlloc +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsSwitchExpression +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsThrow +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsTupleConversion +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsTupleLiteralConversion +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsUnboxing +Microsoft.CodeAnalysis.CSharp.Conversion.get_IsUserDefined +Microsoft.CodeAnalysis.CSharp.Conversion.get_MethodSymbol +Microsoft.CodeAnalysis.CSharp.Conversion.op_Equality(Microsoft.CodeAnalysis.CSharp.Conversion,Microsoft.CodeAnalysis.CSharp.Conversion) +Microsoft.CodeAnalysis.CSharp.Conversion.op_Inequality(Microsoft.CodeAnalysis.CSharp.Conversion,Microsoft.CodeAnalysis.CSharp.Conversion) +Microsoft.CodeAnalysis.CSharp.DeconstructionInfo +Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Conversion +Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Method +Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Nested +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo) +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.GetHashCode +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_CurrentConversion +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_CurrentProperty +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_DisposeMethod +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_ElementConversion +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_ElementType +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_GetEnumeratorMethod +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_IsAsynchronous +Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_MoveNextMethod +Microsoft.CodeAnalysis.CSharp.InterceptableLocation +Microsoft.CodeAnalysis.CSharp.InterceptableLocation.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetDisplayLocation +Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetHashCode +Microsoft.CodeAnalysis.CSharp.InterceptableLocation.get_Data +Microsoft.CodeAnalysis.CSharp.InterceptableLocation.get_Version +Microsoft.CodeAnalysis.CSharp.LanguageVersion +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp1 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp10 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp11 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp13 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp2 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp3 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp4 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp5 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp6 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_1 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_2 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_3 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp8 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp9 +Microsoft.CodeAnalysis.CSharp.LanguageVersion.Default +Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest +Microsoft.CodeAnalysis.CSharp.LanguageVersion.LatestMajor +Microsoft.CodeAnalysis.CSharp.LanguageVersion.Preview +Microsoft.CodeAnalysis.CSharp.LanguageVersion.value__ +Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts +Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.MapSpecifiedToEffectiveVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion) +Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.ToDisplayString(Microsoft.CodeAnalysis.CSharp.LanguageVersion) +Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.TryParse(System.String,Microsoft.CodeAnalysis.CSharp.LanguageVersion@) +Microsoft.CodeAnalysis.CSharp.QueryClauseInfo +Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(Microsoft.CodeAnalysis.CSharp.QueryClauseInfo) +Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(System.Object) +Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.GetHashCode +Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.get_CastInfo +Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.get_OperationInfo +Microsoft.CodeAnalysis.CSharp.SymbolDisplay +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(System.Char,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatPrimitive(System.Object,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.AddAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithAccessors(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_Accessors +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithColonColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_Alias +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_ColonColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.AddConstraints(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.WithAllowsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.get_AllowsKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.get_Constraints +Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_AsyncKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_AsyncKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_DelegateKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.AddInitializers(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_Initializers +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.get_NameEquals +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_Arguments +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_NameColon +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_RefKindKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_RefOrOutKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.AddTypeRankSpecifiers(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.AddSizes(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithSizes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_Rank +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_Sizes +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.AddRankSpecifiers(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithRankSpecifiers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.get_ElementType +Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.get_RankSpecifiers +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.get_ArrowToken +Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_Left +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_Right +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_Arguments +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_NameColon +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_NameEquals +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithAttributes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithTarget(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_Attributes +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_Target +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.get_AwaitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.get_Arguments +Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.get_Token +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.AddTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithTypes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.get_Types +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Externs +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_NamespaceKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Usings +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_AccessorList +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_BaseList +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_Left +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_Right +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_Left +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_Right +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_Statements +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_Arguments +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.get_BranchTaken +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_BreakKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_WhenClause +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_Value +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithCatchKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithFilter(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_CatchKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Filter +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithFilterExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_FilterExpression +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_WhenKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_BaseList +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.get_ClassOrStructKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.get_QuestionToken +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.AddElements(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_Elements +Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_AwaitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_ForEachKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_InKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetLoadDirectives +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetReferenceDirectives +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithEndOfFileToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_EndOfFileToken +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Externs +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Usings +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithWhenNotNull(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_WhenNotNull +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.get_ConditionValue +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenFalse(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenTrue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_QuestionToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_WhenFalse +Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_WhenTrue +Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithThisOrBaseKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ThisOrBaseKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithContinueKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_ContinueKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_CheckedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ImplicitOrExplicitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_OperatorKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_CheckedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_ImplicitOrExplicitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_OperatorKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_ReadOnlyKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_RefKindKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_RefOrOutKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.get_Designation +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.get_Designation +Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.WithDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.get_DefaultKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithDefineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_DefineKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Arity +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_DelegateKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ReturnType +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithTildeToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_TildeToken +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetNextDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetPreviousDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetRelatedDirectives +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_DirectiveNameToken +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.get_UnderscoreToken +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.get_UnderscoreToken +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithDoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_DoKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_WhileKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.AddContent(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithEndOfComment(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.get_Content +Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.get_EndOfComment +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithConditionValue(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithElifKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_BranchTaken +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_ConditionValue +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_ElifKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.get_ElseKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_BranchTaken +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_ElseKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_EndIfKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_EndRegionKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithEnumKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_BaseList +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_EnumKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithEqualsValue(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_EqualsValue +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.get_Value +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithErrorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_ErrorKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_AccessorList +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_EventKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_EventKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.get_DotToken +Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_AllowsAnyExpression +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithAliasKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithExternKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_AliasKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_ExternKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FieldExpressionSyntax.get_Token +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Externs +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_NamespaceKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Usings +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithFinallyKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.get_FinallyKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithFixedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_FixedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_AwaitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_ForEachKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_InKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithVariable(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_AwaitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_ForEachKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_InKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Variable +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddIncrementors(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddInitializers(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithFirstSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithForKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithIncrementors(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithSecondSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_FirstSemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_ForKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Incrementors +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Initializers +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_SecondSemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithFromKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_FromKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_InKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedOrUnmanagedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.get_ManagedOrUnmanagedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.get_UnmanagedCallingConventionList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_GreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_LessThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_AsteriskToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_CallingConvention +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_DelegateKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.AddCallingConventions(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_CallingConventions +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.AddTypeArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_IsUnboundGenericName +Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_TypeArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithCaseOrDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithGotoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_CaseOrDefaultKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_GotoKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_ByExpression +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_ByKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_GroupExpression +Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_GroupKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithConditionValue(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_BranchTaken +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_ConditionValue +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_IfKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithElse(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Else +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_IfKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddCommas(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCommas(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_Commas +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_StackAllocKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_AccessorList +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Semicolon +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ThisKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.get_ThisKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.AddExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithExpressions(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_Expressions +Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.InstanceExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_BaseList +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.AddContents(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithContents(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringEndToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringStartToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_Contents +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_StringEndToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_StringStartToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.WithTextToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.get_TextToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.get_CommaToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.get_Value +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithFormatStringToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.get_FormatStringToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_AlignmentClause +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_FormatClause +Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithIsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_IsKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithEqualsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInto(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithJoinKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithLeftExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithOnKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithRightExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_EqualsKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_InExpression +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_InKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Into +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_JoinKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_LeftExpression +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_OnKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_RightExpression +Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.get_IntoKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.get_ArrowToken +Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithLetKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_LetKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCharacter(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_Character +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_CommaToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_Line +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_File +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_Line +Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_LineKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.get_File +Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.get_LineKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithCharacterOffset(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEnd(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithMinusToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithStart(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_CharacterOffset +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_End +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_File +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_LineKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_MinusToken +Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_Start +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.AddPatterns(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithPatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_CloseBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_Designation +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_OpenBracketToken +Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_Patterns +Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.get_Token +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithLoadKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_File +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_LoadKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_AwaitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_IsConst +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_UsingKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ReturnType +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithLockKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_LockKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Arity +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ReturnType +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax.get_Arity +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Externs +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_NamespaceKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Usings +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithNullableKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithSettingToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithTargetToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_NullableKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_SettingToken +Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_TargetToken +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.get_ElementType +Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.get_QuestionToken +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_NewKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.WithOmittedArraySizeExpressionToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.get_OmittedArraySizeExpressionToken +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.WithOmittedTypeArgumentToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.get_OmittedTypeArgumentToken +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_CheckedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_OperatorKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ReturnType +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_CheckedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_OperatorKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.AddOrderings(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderByKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderings(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.get_OrderByKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.get_Orderings +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithAscendingOrDescendingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.get_AscendingOrDescendingKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Default +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ArrowToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_AsyncKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ReturnType +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.AddVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_Variables +Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.get_AsteriskToken +Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.get_ElementType +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.AddSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_Subpatterns +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.get_Operand +Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithBytes(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithChecksumKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithGuid(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_Bytes +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_ChecksumKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_File +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_Guid +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_PragmaKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.AddErrorCodes(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithDisableOrRestoreKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithErrorCodes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_DisableOrRestoreKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_ErrorCodes +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_PragmaKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_WarningKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.get_Operand +Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_AccessorList +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Semicolon +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.AddSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_Subpatterns +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithContainer(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithMember(Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_Container +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_DotToken +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_Member +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_DotToken +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_Left +Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_Right +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.AddClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithSelectOrGroup(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_Clauses +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_Continuation +Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_SelectOrGroup +Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.AddBodyClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_IntoKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.AddBodyClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.get_Body +Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.get_FromClause +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithLeftOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithRightOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_LeftOperand +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_RightOperand +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_BaseList +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ClassOrStructKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPositionalPatternClauseSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPropertyPatternClauseSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_Designation +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_PositionalPatternClause +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_PropertyPatternClause +Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.get_RefKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.WithStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.get_RefKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.get_StructKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_ReadOnlyKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_RefKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithComma(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Comma +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithReferenceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_File +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_ReferenceKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_RegionKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithReturnKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_ReturnKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.WithScopedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.get_ScopedKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithSelectKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.get_SelectKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithExclamationToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_ExclamationToken +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_ArrowToken +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_AsyncKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_ExpressionBody +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Parameter +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.AddTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.WithTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.get_Tokens +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithDotDotToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.get_DotDotToken +Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_StackAllocKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_BaseList +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Modifiers +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax.get_ParentTrivia +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_ExpressionColon +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_NameColon +Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithEqualsGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_EqualsGreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_WhenClause +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.AddArms(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithArms(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithGoverningExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_Arms +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_GoverningExpression +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_SwitchKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddLabels(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithLabels(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.get_Labels +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.get_Statements +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddSections(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSections(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_CloseBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_OpenBraceToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_Sections +Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_SwitchKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.get_Token +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.get_ThrowKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_ThrowKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddCatches(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithCatches(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithFinally(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithTryKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Catches +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Finally +Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_TryKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_Arguments +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.AddElements(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_Elements +Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_Arguments +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_GreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_LessThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Arity +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_ConstraintClauses +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Members +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_ParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_TypeParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_Keyword +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.AddConstraints(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_Constraints +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_WhereKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_GreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_LessThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_Parameters +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithVarianceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_VarianceKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNint +Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNotNull +Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNuint +Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsUnmanaged +Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsVar +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.get_OperatorToken +Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.get_Pattern +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithUndefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_UndefKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_Block +Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_UnsafeKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithGlobalKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithNamespaceOrType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithStaticKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_Alias +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_GlobalKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_NamespaceOrType +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_StaticKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_UnsafeKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_UsingKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_AwaitKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Declaration +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_UsingKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithVarKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.get_Designation +Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.get_VarKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.AddVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.get_Type +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.get_Variables +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_ArgumentList +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithIsActive(System.Boolean) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_HashToken +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_IsActive +Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_WarningKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.get_WhenKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.get_WhereKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_CloseParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_Condition +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_OpenParenToken +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_Statement +Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_WhileKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithWithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_Initializer +Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_WithKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_EndQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_StartQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithEndCDataToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithStartCDataToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_EndCDataToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_StartCDataToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_TextTokens +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithLessThanExclamationMinusMinusToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithMinusMinusGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_LessThanExclamationMinusMinusToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_MinusMinusGreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_TextTokens +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_Cref +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_EndQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_StartQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithLessThanSlashToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_GreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_LessThanSlashToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_Attributes +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_GreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_LessThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddContent(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddStartTagAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_Content +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_EndTag +Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_StartTag +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithSlashGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_Attributes +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_LessThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_SlashGreaterThanToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.Parameter +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.ParameterReference +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameter +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameterReference +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.value__ +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_EndQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_Identifier +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_StartQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithLocalName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.get_LocalName +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.get_Prefix +Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithPrefix(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.get_ColonToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.get_Prefix +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithEndProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithStartProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_EndProcessingInstructionToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_StartProcessingInstructionToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_TextTokens +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_EndQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_EqualsToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_Name +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_StartQuoteToken +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_TextTokens +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.get_TextTokens +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithReturnOrBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithYieldKeyword(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_AttributeLists +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_Expression +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_ReturnOrBreakKeyword +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_SemicolonToken +Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_YieldKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxToken,System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxToken,System.String,System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.ToSyntaxTriviaList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AllowsConstraintClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AllowsConstraintClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.SyntaxList{``0},System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.SyntaxList{``0},System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadToken(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CollectionExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CollectionExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Comment(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CreateTokenParser(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DisabledText(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentExterior(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticEndOfLine(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticWhitespace(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldExpression(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetNonGenericExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetStandaloneExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationAlignmentClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsCompleteSubmission(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List``1 +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List``1(System.Collections.Generic.IEnumerable{``0}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Char,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Decimal,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Double,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Int32,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Int64,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Single,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.UInt32,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.UInt64,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Char) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Decimal) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Double) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Int32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Int64) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Single) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Char) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Decimal) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Double) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Int32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Int64) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Single) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.UInt32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.UInt64) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.UInt32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.UInt64) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(Microsoft.CodeAnalysis.SyntaxNodeOrToken[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseAttributeArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedParameterList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseCompilationUnit(System.String,System.Int32,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseExpression(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseLeadingTrivia(System.String,System.Int32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseMemberDeclaration(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseName(System.String,System.Int32,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseParameterList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseStatement(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseToken(System.String,System.Int32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTokens(System.String,System.Int32,System.Int32,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTrailingTrivia(System.String,System.Int32) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(System.String,System.Int32,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PredefinedType(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PreprocessingMessage(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefStructConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefStructConstraint(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RelationalPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ScopedType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1 +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{``0}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingleVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonList``1(``0) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonSeparatedList``1(``0) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SpreadElement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Trivia(Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEntity(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.String,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNewLine(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNullKeywordElement +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamRefElement(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPreliminaryElement +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(System.Uri,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(System.String,System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(System.String,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement(System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_CarriageReturn +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_CarriageReturnLineFeed +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticCarriageReturn +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticCarriageReturnLineFeed +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticLineFeed +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticMarker +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticSpace +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticTab +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_LineFeed +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_Space +Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_Tab +Microsoft.CodeAnalysis.CSharp.SyntaxFacts +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAccessorDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBaseTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetCheckStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKind(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKinds +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKind(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKinds +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetOperatorKind(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKind(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKinds +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPunctuationKinds +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetReservedKeywordKinds +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetSwitchLabelKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.Accessibility) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessibilityModifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclarationKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAliasQualifier(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyOverloadableOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeName(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsCheckedOperator(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsFixedStatementExpression(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsGlobalMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierPartCharacter(System.Char) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierStartCharacter(System.Char) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInNamespaceOrTypeContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInTypeOnlyContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIndexed(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInvoked(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsKeywordKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLambdaBody(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLanguagePunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsName(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamedArgumentName(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceAliasQualifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNewLine(System.Char) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableBinaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableUnaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPostfixUnaryExpressionToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPredefinedType(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrefixUnaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorDirective(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorPunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuationOrKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsQueryContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedTupleElementName(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeParameterVarianceKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeSyntax(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsUnaryOperatorDeclarationToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsValidIdentifier(System.String) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsWhitespace(System.Char) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.TryGetInferredMemberName(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.CSharp.SyntaxFacts.get_EqualityComparer +Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AbstractKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AccessorList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAccessorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddressOfExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AliasKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AliasQualifiedName +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AllowsConstraintClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AllowsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandAmpersandToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnnotationsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousMethodExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousObjectCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousObjectMemberDeclarator +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgListExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgListKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Argument +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgumentList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayInitializerExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayRankSpecifier +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrowExpressionClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AscendingKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AscendingOrdering +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AssemblyKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsteriskEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsteriskToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsyncKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Attribute +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeArgument +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeArgumentList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeTargetSpecifier +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AwaitExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.AwaitKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BackslashToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BadDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BadToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarBarToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseConstructorInitializer +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseAndExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseNotExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseOrExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Block +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BoolKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BracketedArgumentList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BracketedParameterList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BreakKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.BreakStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ByKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ByteKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaretEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaretToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaseKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CasePatternSwitchLabel +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaseSwitchLabel +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CastExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchFilterClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharacterLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharacterLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ChecksumKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseBraceToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseBracketToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseParenToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CoalesceAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CoalesceExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CollectionExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CollectionInitializerExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ColonColonToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ColonToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CommaToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CompilationUnit +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ComplexElementInitializerExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConditionalAccessExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConditionalExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConflictMarkerTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstantPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstructorConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstructorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ContinueKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ContinueStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConversionOperatorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConversionOperatorMemberCref +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefBracketedParameterList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefParameter +Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefParameterList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DecimalKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DeclarationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DeclarationPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultSwitchLabel +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DelegateDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DelegateKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DescendingKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DescendingOrdering +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DestructorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DisableKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DisabledTextTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DiscardDesignation +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DiscardPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DocumentationCommentExteriorTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DollarToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DotDotToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DotToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoubleKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoubleQuoteToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElementAccessExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElementBindingExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElifDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElifKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EmptyStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnableKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndIfDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndIfKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfDirectiveToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfDocumentationCommentToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfFileToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfLineTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndRegionDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndRegionKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumMemberDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsGreaterThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsValueClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ErrorDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ErrorKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventFieldDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclusiveOrAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclusiveOrExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExplicitInterfaceSpecifier +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExplicitKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionColon +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionElement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExternAliasDirective +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExternKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FalseKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FalseLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileScopedNamespaceDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FinallyClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FinallyKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FixedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FixedStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FloatKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachVariableStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FromClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FromKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerCallingConvention +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameter +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConvention +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConventionList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GenericName +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetAccessorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GlobalKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GlobalStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoCaseStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoDefaultStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanGreaterThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanOrEqualExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GroupClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.GroupKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.HashToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.HiddenKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierName +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitArrayCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitElementAccess +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitObjectCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitStackAllocArrayCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IncompleteMember +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexerDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexerMemberCref +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InitAccessorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InitKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IntKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedMultiLineRawStringStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedRawStringEndToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedSingleLineRawStringStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringEndToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringText +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringTextToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedVerbatimStringStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Interpolation +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolationAlignmentClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolationFormatClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IntoKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.InvocationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsPatternExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinIntoClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LabeledStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LeftShiftAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LeftShiftExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanLessThanEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanLessThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanOrEqualExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanSlashToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LetClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LetKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectivePosition +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineSpanDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.List +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ListPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LoadDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LoadKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LocalDeclarationStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LocalFunctionStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LockKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LockStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalAndExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalNotExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalOrExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.LongKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MakeRefExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MakeRefKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ManagedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MemberBindingExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MethodDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MethodKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusGreaterThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusMinusToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuleKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuloAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuloExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineCommentTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineDocumentationCommentTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineRawStringLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameColon +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameEquals +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameMemberCref +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameOfKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NamespaceDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NamespaceKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NewKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.None +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotEqualsExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectInitializerExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedArraySizeExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedArraySizeExpressionToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedTypeArgument +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedTypeArgumentToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OnKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenBraceToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenBracketToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenParenToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorMemberCref +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrderByClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrderByKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OutKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.OverrideKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParamKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Parameter +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParameterList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParamsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedLambdaExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedVariableDesignation +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PartialKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PercentEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PercentToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusPlusToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerIndirectionExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerMemberAccessExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PositionalPatternClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostDecrementExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostIncrementExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaChecksumDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaWarningDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreDecrementExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreIncrementExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PredefinedType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreprocessingMessageTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrimaryConstructorBaseType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrivateKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyPatternClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.PublicKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QualifiedCref +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QualifiedName +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryBody +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryContinuation +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionQuestionEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionQuestionToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RangeExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RazorContentToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReadOnlyKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordStructDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecursivePattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefStructConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefTypeExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefTypeKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefValueExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefValueKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReferenceDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReferenceKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RegionDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RegionKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RelationalPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveAccessorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RequiredKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RestoreKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReturnKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReturnStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RightShiftAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.RightShiftExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SByteKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ScopedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ScopedType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SealedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SelectClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SelectKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SemicolonToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetAccessorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ShebangDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ShortKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleBaseType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleLambdaExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleMemberAccessExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineCommentTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineDocumentationCommentTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineRawStringLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleQuoteToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleVariableDesignation +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SizeOfExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SizeOfKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SkippedTokensTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashEqualsToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashGreaterThanToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlicePattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SpreadElement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StackAllocArrayCreationExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StackAllocKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StaticKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Subpattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SuppressNullableWarningExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchExpressionArm +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchSection +Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisConstructorInitializer +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TildeToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TrueKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TrueLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TryKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TryStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleElement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleType +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeArgumentList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeConstraint +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeCref +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeOfExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeOfKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameter +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameterConstraintClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameterList +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypePattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeVarKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UIntKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ULongKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UShortKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryMinusExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryPlusExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UndefDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UndefKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnderscoreToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnknownAccessorDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnmanagedKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsafeKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsafeStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsignedRightShiftAssignmentExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsignedRightShiftExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingDirective +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8MultiLineRawStringLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8SingleLineRawStringLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8StringLiteralExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8StringLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VarKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VarPattern +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VariableDeclaration +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VariableDeclarator +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VirtualKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VoidKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.VolatileKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningDirectiveTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningsKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhenClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhenKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhereClause +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhereKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhileKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhileStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhitespaceTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithInitializerExpression +Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataEndToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataSection +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlComment +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCommentEndToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCommentStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCrefAttribute +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElementEndTag +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElementStartTag +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlEmptyElement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlEntityLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlName +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlNameAttribute +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlPrefix +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstruction +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstructionEndToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstructionStartToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlText +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextAttribute +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextLiteralNewLineToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextLiteralToken +Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldBreakStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldKeyword +Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldReturnStatement +Microsoft.CodeAnalysis.CSharp.SyntaxKind.value__ +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Dispose +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseLeadingTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseNextToken +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseTrailingTrivia +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ResetTo(Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result) +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result.get_ContextualKind +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result.get_Token +Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.SkipForwardTo(System.Int32) +Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions +Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions.ToCSharpString(Microsoft.CodeAnalysis.TypedConstant) +Microsoft.CodeAnalysis.CSharpExtensions +Microsoft.CodeAnalysis.CSharpExtensions.Any(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.Any(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.Any``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.Any``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.ContainsDirective(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IndexOf``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IndexOf``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.CSharp.SyntaxKind) \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.txt new file mode 100644 index 0000000000000..7f8d403ef4ae5 --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.txt @@ -0,0 +1,4100 @@ +# Generated, do not update manually +Microsoft.CodeAnalysis.Accessibility +Microsoft.CodeAnalysis.Accessibility.Friend +Microsoft.CodeAnalysis.Accessibility.Internal +Microsoft.CodeAnalysis.Accessibility.NotApplicable +Microsoft.CodeAnalysis.Accessibility.Private +Microsoft.CodeAnalysis.Accessibility.Protected +Microsoft.CodeAnalysis.Accessibility.ProtectedAndFriend +Microsoft.CodeAnalysis.Accessibility.ProtectedAndInternal +Microsoft.CodeAnalysis.Accessibility.ProtectedOrFriend +Microsoft.CodeAnalysis.Accessibility.ProtectedOrInternal +Microsoft.CodeAnalysis.Accessibility.Public +Microsoft.CodeAnalysis.Accessibility.value__ +Microsoft.CodeAnalysis.AdditionalText +Microsoft.CodeAnalysis.AdditionalText.#ctor +Microsoft.CodeAnalysis.AdditionalText.GetText(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.AdditionalText.get_Path +Microsoft.CodeAnalysis.AnalyzerConfig +Microsoft.CodeAnalysis.AnalyzerConfig.Parse(Microsoft.CodeAnalysis.Text.SourceText,System.String) +Microsoft.CodeAnalysis.AnalyzerConfig.Parse(System.String,System.String) +Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult +Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_AnalyzerOptions +Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_Diagnostics +Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_TreeOptions +Microsoft.CodeAnalysis.AnalyzerConfigSet +Microsoft.CodeAnalysis.AnalyzerConfigSet.Create``1(``0) +Microsoft.CodeAnalysis.AnalyzerConfigSet.Create``1(``0,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic}@) +Microsoft.CodeAnalysis.AnalyzerConfigSet.GetOptionsForSourcePath(System.String) +Microsoft.CodeAnalysis.AnalyzerConfigSet.get_GlobalConfigOptions +Microsoft.CodeAnalysis.AnnotationExtensions +Microsoft.CodeAnalysis.AnnotationExtensions.WithAdditionalAnnotations``1(``0,Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.AnnotationExtensions.WithAdditionalAnnotations``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,System.String) +Microsoft.CodeAnalysis.AssemblyIdentity +Microsoft.CodeAnalysis.AssemblyIdentity.#ctor(System.String,System.Version,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Boolean,System.Boolean,System.Reflection.AssemblyContentType) +Microsoft.CodeAnalysis.AssemblyIdentity.Equals(Microsoft.CodeAnalysis.AssemblyIdentity) +Microsoft.CodeAnalysis.AssemblyIdentity.Equals(System.Object) +Microsoft.CodeAnalysis.AssemblyIdentity.FromAssemblyDefinition(System.Reflection.Assembly) +Microsoft.CodeAnalysis.AssemblyIdentity.GetDisplayName(System.Boolean) +Microsoft.CodeAnalysis.AssemblyIdentity.GetHashCode +Microsoft.CodeAnalysis.AssemblyIdentity.ToString +Microsoft.CodeAnalysis.AssemblyIdentity.TryParseDisplayName(System.String,Microsoft.CodeAnalysis.AssemblyIdentity@) +Microsoft.CodeAnalysis.AssemblyIdentity.TryParseDisplayName(System.String,Microsoft.CodeAnalysis.AssemblyIdentity@,Microsoft.CodeAnalysis.AssemblyIdentityParts@) +Microsoft.CodeAnalysis.AssemblyIdentity.get_ContentType +Microsoft.CodeAnalysis.AssemblyIdentity.get_CultureName +Microsoft.CodeAnalysis.AssemblyIdentity.get_Flags +Microsoft.CodeAnalysis.AssemblyIdentity.get_HasPublicKey +Microsoft.CodeAnalysis.AssemblyIdentity.get_IsRetargetable +Microsoft.CodeAnalysis.AssemblyIdentity.get_IsStrongName +Microsoft.CodeAnalysis.AssemblyIdentity.get_Name +Microsoft.CodeAnalysis.AssemblyIdentity.get_PublicKey +Microsoft.CodeAnalysis.AssemblyIdentity.get_PublicKeyToken +Microsoft.CodeAnalysis.AssemblyIdentity.get_Version +Microsoft.CodeAnalysis.AssemblyIdentity.op_Equality(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +Microsoft.CodeAnalysis.AssemblyIdentity.op_Inequality(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +Microsoft.CodeAnalysis.AssemblyIdentityComparer +Microsoft.CodeAnalysis.AssemblyIdentityComparer.Compare(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.Equivalent +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.EquivalentIgnoringVersion +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.NotEquivalent +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.value__ +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ReferenceMatchesDefinition(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +Microsoft.CodeAnalysis.AssemblyIdentityComparer.ReferenceMatchesDefinition(System.String,Microsoft.CodeAnalysis.AssemblyIdentity) +Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_CultureComparer +Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_Default +Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_SimpleNameComparer +Microsoft.CodeAnalysis.AssemblyIdentityParts +Microsoft.CodeAnalysis.AssemblyIdentityParts.ContentType +Microsoft.CodeAnalysis.AssemblyIdentityParts.Culture +Microsoft.CodeAnalysis.AssemblyIdentityParts.Name +Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKey +Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKeyOrToken +Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKeyToken +Microsoft.CodeAnalysis.AssemblyIdentityParts.Retargetability +Microsoft.CodeAnalysis.AssemblyIdentityParts.Unknown +Microsoft.CodeAnalysis.AssemblyIdentityParts.Version +Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionBuild +Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionMajor +Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionMinor +Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionRevision +Microsoft.CodeAnalysis.AssemblyIdentityParts.value__ +Microsoft.CodeAnalysis.AssemblyMetadata +Microsoft.CodeAnalysis.AssemblyMetadata.CommonCopy +Microsoft.CodeAnalysis.AssemblyMetadata.Dispose +Microsoft.CodeAnalysis.AssemblyMetadata.GetModules +Microsoft.CodeAnalysis.AssemblyMetadata.GetReference(Microsoft.CodeAnalysis.DocumentationProvider,System.Collections.Immutable.ImmutableArray{System.String},System.Boolean,System.String,System.String) +Microsoft.CodeAnalysis.AssemblyMetadata.get_Kind +Microsoft.CodeAnalysis.AttributeData +Microsoft.CodeAnalysis.AttributeData.#ctor +Microsoft.CodeAnalysis.AttributeData.get_ApplicationSyntaxReference +Microsoft.CodeAnalysis.AttributeData.get_AttributeClass +Microsoft.CodeAnalysis.AttributeData.get_AttributeConstructor +Microsoft.CodeAnalysis.AttributeData.get_CommonApplicationSyntaxReference +Microsoft.CodeAnalysis.AttributeData.get_CommonAttributeClass +Microsoft.CodeAnalysis.AttributeData.get_CommonAttributeConstructor +Microsoft.CodeAnalysis.AttributeData.get_CommonConstructorArguments +Microsoft.CodeAnalysis.AttributeData.get_CommonNamedArguments +Microsoft.CodeAnalysis.AttributeData.get_ConstructorArguments +Microsoft.CodeAnalysis.AttributeData.get_NamedArguments +Microsoft.CodeAnalysis.CandidateReason +Microsoft.CodeAnalysis.CandidateReason.Ambiguous +Microsoft.CodeAnalysis.CandidateReason.Inaccessible +Microsoft.CodeAnalysis.CandidateReason.LateBound +Microsoft.CodeAnalysis.CandidateReason.MemberGroup +Microsoft.CodeAnalysis.CandidateReason.None +Microsoft.CodeAnalysis.CandidateReason.NotATypeOrNamespace +Microsoft.CodeAnalysis.CandidateReason.NotAValue +Microsoft.CodeAnalysis.CandidateReason.NotAVariable +Microsoft.CodeAnalysis.CandidateReason.NotAWithEventsMember +Microsoft.CodeAnalysis.CandidateReason.NotAnAttributeType +Microsoft.CodeAnalysis.CandidateReason.NotAnEvent +Microsoft.CodeAnalysis.CandidateReason.NotCreatable +Microsoft.CodeAnalysis.CandidateReason.NotInvocable +Microsoft.CodeAnalysis.CandidateReason.NotReferencable +Microsoft.CodeAnalysis.CandidateReason.OverloadResolutionFailure +Microsoft.CodeAnalysis.CandidateReason.StaticInstanceMismatch +Microsoft.CodeAnalysis.CandidateReason.WrongArity +Microsoft.CodeAnalysis.CandidateReason.value__ +Microsoft.CodeAnalysis.CaseInsensitiveComparison +Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.String,System.String) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.EndsWith(System.String,System.String) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.String,System.String) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.GetHashCode(System.String) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.StartsWith(System.String,System.String) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.Char) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.String) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.Text.StringBuilder) +Microsoft.CodeAnalysis.CaseInsensitiveComparison.get_Comparer +Microsoft.CodeAnalysis.ChildSyntaxList +Microsoft.CodeAnalysis.ChildSyntaxList.Any +Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator +Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.MoveNext +Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.Reset +Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.get_Current +Microsoft.CodeAnalysis.ChildSyntaxList.Equals(Microsoft.CodeAnalysis.ChildSyntaxList) +Microsoft.CodeAnalysis.ChildSyntaxList.Equals(System.Object) +Microsoft.CodeAnalysis.ChildSyntaxList.First +Microsoft.CodeAnalysis.ChildSyntaxList.GetEnumerator +Microsoft.CodeAnalysis.ChildSyntaxList.GetHashCode +Microsoft.CodeAnalysis.ChildSyntaxList.Last +Microsoft.CodeAnalysis.ChildSyntaxList.Reverse +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.MoveNext +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.Reset +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.get_Current +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Equals(Microsoft.CodeAnalysis.ChildSyntaxList.Reversed) +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Equals(System.Object) +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.GetEnumerator +Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.GetHashCode +Microsoft.CodeAnalysis.ChildSyntaxList.get_Count +Microsoft.CodeAnalysis.ChildSyntaxList.get_Item(System.Int32) +Microsoft.CodeAnalysis.ChildSyntaxList.op_Equality(Microsoft.CodeAnalysis.ChildSyntaxList,Microsoft.CodeAnalysis.ChildSyntaxList) +Microsoft.CodeAnalysis.ChildSyntaxList.op_Inequality(Microsoft.CodeAnalysis.ChildSyntaxList,Microsoft.CodeAnalysis.ChildSyntaxList) +Microsoft.CodeAnalysis.Compilation +Microsoft.CodeAnalysis.Compilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference[]) +Microsoft.CodeAnalysis.Compilation.AddReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.Compilation.AddSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +Microsoft.CodeAnalysis.Compilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.Compilation.AppendDefaultVersionResource(System.IO.Stream) +Microsoft.CodeAnalysis.Compilation.CheckTupleElementLocations(System.Int32,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +Microsoft.CodeAnalysis.Compilation.CheckTupleElementNames(System.Int32,System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.Compilation.CheckTupleElementNullableAnnotations(System.Int32,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.Clone +Microsoft.CodeAnalysis.Compilation.CommonAddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.Compilation.CommonBindScriptClass +Microsoft.CodeAnalysis.Compilation.CommonClone +Microsoft.CodeAnalysis.Compilation.CommonContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.Compilation.CommonCreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.CommonCreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) +Microsoft.CodeAnalysis.Compilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.CommonCreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) +Microsoft.CodeAnalysis.Compilation.CommonCreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) +Microsoft.CodeAnalysis.Compilation.CommonCreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) +Microsoft.CodeAnalysis.Compilation.CommonCreateNativeIntegerTypeSymbol(System.Boolean) +Microsoft.CodeAnalysis.Compilation.CommonCreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.CommonCreatePreprocessingSymbol(System.String) +Microsoft.CodeAnalysis.Compilation.CommonCreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.CommonCreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.CommonGetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) +Microsoft.CodeAnalysis.Compilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +Microsoft.CodeAnalysis.Compilation.CommonGetEntryPoint(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +Microsoft.CodeAnalysis.Compilation.CommonGetTypeByMetadataName(System.String) +Microsoft.CodeAnalysis.Compilation.CommonRemoveAllSyntaxTrees +Microsoft.CodeAnalysis.Compilation.CommonRemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.Compilation.CommonReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.Compilation.CommonWithAssemblyName(System.String) +Microsoft.CodeAnalysis.Compilation.CommonWithOptions(Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.Compilation.CommonWithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.Compilation.CommonWithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) +Microsoft.CodeAnalysis.Compilation.ContainsSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.ContainsSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.CreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32) +Microsoft.CodeAnalysis.Compilation.CreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) +Microsoft.CodeAnalysis.Compilation.CreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.CreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.CreateDefaultWin32Resources(System.Boolean,System.Boolean,System.IO.Stream,System.IO.Stream) +Microsoft.CodeAnalysis.Compilation.CreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) +Microsoft.CodeAnalysis.Compilation.CreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) +Microsoft.CodeAnalysis.Compilation.CreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) +Microsoft.CodeAnalysis.Compilation.CreateNativeIntegerTypeSymbol(System.Boolean) +Microsoft.CodeAnalysis.Compilation.CreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.CreatePreprocessingSymbol(System.String) +Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.Compilation.GetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) +Microsoft.CodeAnalysis.Compilation.GetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +Microsoft.CodeAnalysis.Compilation.GetDeclarationDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetEntryPoint(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol) +Microsoft.CodeAnalysis.Compilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetParseDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetRequiredLanguageVersion(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +Microsoft.CodeAnalysis.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType) +Microsoft.CodeAnalysis.Compilation.GetSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.GetTypeByMetadataName(System.String) +Microsoft.CodeAnalysis.Compilation.GetTypesByMetadataName(System.String) +Microsoft.CodeAnalysis.Compilation.GetUnreferencedAssemblyIdentities(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Compilation.GetUsedAssemblyReferences(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Compilation.HasImplicitConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.IsSymbolAccessibleWithin(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.Compilation.RemoveAllReferences +Microsoft.CodeAnalysis.Compilation.RemoveAllSyntaxTrees +Microsoft.CodeAnalysis.Compilation.RemoveReferences(Microsoft.CodeAnalysis.MetadataReference[]) +Microsoft.CodeAnalysis.Compilation.RemoveReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.Compilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.MetadataReference) +Microsoft.CodeAnalysis.Compilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.Compilation.SupportsRuntimeCapability(Microsoft.CodeAnalysis.RuntimeCapability) +Microsoft.CodeAnalysis.Compilation.SyntaxTreeCommonFeatures(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.Compilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) +Microsoft.CodeAnalysis.Compilation.WithAssemblyName(System.String) +Microsoft.CodeAnalysis.Compilation.WithOptions(Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.Compilation.WithReferences(Microsoft.CodeAnalysis.MetadataReference[]) +Microsoft.CodeAnalysis.Compilation.WithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +Microsoft.CodeAnalysis.Compilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) +Microsoft.CodeAnalysis.Compilation._features +Microsoft.CodeAnalysis.Compilation.get_Assembly +Microsoft.CodeAnalysis.Compilation.get_AssemblyName +Microsoft.CodeAnalysis.Compilation.get_CommonAssembly +Microsoft.CodeAnalysis.Compilation.get_CommonDynamicType +Microsoft.CodeAnalysis.Compilation.get_CommonGlobalNamespace +Microsoft.CodeAnalysis.Compilation.get_CommonObjectType +Microsoft.CodeAnalysis.Compilation.get_CommonOptions +Microsoft.CodeAnalysis.Compilation.get_CommonScriptClass +Microsoft.CodeAnalysis.Compilation.get_CommonScriptGlobalsType +Microsoft.CodeAnalysis.Compilation.get_CommonSourceModule +Microsoft.CodeAnalysis.Compilation.get_CommonSyntaxTrees +Microsoft.CodeAnalysis.Compilation.get_DirectiveReferences +Microsoft.CodeAnalysis.Compilation.get_DynamicType +Microsoft.CodeAnalysis.Compilation.get_ExternalReferences +Microsoft.CodeAnalysis.Compilation.get_GlobalNamespace +Microsoft.CodeAnalysis.Compilation.get_IsCaseSensitive +Microsoft.CodeAnalysis.Compilation.get_Language +Microsoft.CodeAnalysis.Compilation.get_ObjectType +Microsoft.CodeAnalysis.Compilation.get_Options +Microsoft.CodeAnalysis.Compilation.get_ReferencedAssemblyNames +Microsoft.CodeAnalysis.Compilation.get_References +Microsoft.CodeAnalysis.Compilation.get_ScriptClass +Microsoft.CodeAnalysis.Compilation.get_ScriptCompilationInfo +Microsoft.CodeAnalysis.Compilation.get_SourceModule +Microsoft.CodeAnalysis.Compilation.get_SyntaxTrees +Microsoft.CodeAnalysis.CompilationOptions +Microsoft.CodeAnalysis.CompilationOptions.CommonWithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithCheckOverflow(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithConcurrentBuild(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithDelaySign(System.Nullable{System.Boolean}) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithDeterministic(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithFeatures(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithMainTypeName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithModuleName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithOutputKind(Microsoft.CodeAnalysis.OutputKind) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithPlatform(Microsoft.CodeAnalysis.Platform) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithPublicSign(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithReportSuppressedDiagnostics(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithScriptClassName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +Microsoft.CodeAnalysis.CompilationOptions.CommonWithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.ComputeHashCode +Microsoft.CodeAnalysis.CompilationOptions.Equals(System.Object) +Microsoft.CodeAnalysis.CompilationOptions.EqualsHelper(Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.CompilationOptions.GetHashCode +Microsoft.CodeAnalysis.CompilationOptions.GetHashCodeHelper +Microsoft.CodeAnalysis.CompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +Microsoft.CodeAnalysis.CompilationOptions.WithConcurrentBuild(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.WithDelaySign(System.Nullable{System.Boolean}) +Microsoft.CodeAnalysis.CompilationOptions.WithDeterministic(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +Microsoft.CodeAnalysis.CompilationOptions.WithMainTypeName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +Microsoft.CodeAnalysis.CompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.WithModuleName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +Microsoft.CodeAnalysis.CompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind) +Microsoft.CodeAnalysis.CompilationOptions.WithOverflowChecks(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform) +Microsoft.CodeAnalysis.CompilationOptions.WithPublicSign(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.WithReportSuppressedDiagnostics(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.WithScriptClassName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +Microsoft.CodeAnalysis.CompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.CompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +Microsoft.CodeAnalysis.CompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +Microsoft.CodeAnalysis.CompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.get_AssemblyIdentityComparer +Microsoft.CodeAnalysis.CompilationOptions.get_CheckOverflow +Microsoft.CodeAnalysis.CompilationOptions.get_ConcurrentBuild +Microsoft.CodeAnalysis.CompilationOptions.get_CryptoKeyContainer +Microsoft.CodeAnalysis.CompilationOptions.get_CryptoKeyFile +Microsoft.CodeAnalysis.CompilationOptions.get_CryptoPublicKey +Microsoft.CodeAnalysis.CompilationOptions.get_DelaySign +Microsoft.CodeAnalysis.CompilationOptions.get_Deterministic +Microsoft.CodeAnalysis.CompilationOptions.get_Errors +Microsoft.CodeAnalysis.CompilationOptions.get_Features +Microsoft.CodeAnalysis.CompilationOptions.get_GeneralDiagnosticOption +Microsoft.CodeAnalysis.CompilationOptions.get_Language +Microsoft.CodeAnalysis.CompilationOptions.get_MainTypeName +Microsoft.CodeAnalysis.CompilationOptions.get_MetadataImportOptions +Microsoft.CodeAnalysis.CompilationOptions.get_MetadataReferenceResolver +Microsoft.CodeAnalysis.CompilationOptions.get_ModuleName +Microsoft.CodeAnalysis.CompilationOptions.get_NullableContextOptions +Microsoft.CodeAnalysis.CompilationOptions.get_OptimizationLevel +Microsoft.CodeAnalysis.CompilationOptions.get_OutputKind +Microsoft.CodeAnalysis.CompilationOptions.get_Platform +Microsoft.CodeAnalysis.CompilationOptions.get_PublicSign +Microsoft.CodeAnalysis.CompilationOptions.get_ReportSuppressedDiagnostics +Microsoft.CodeAnalysis.CompilationOptions.get_ScriptClassName +Microsoft.CodeAnalysis.CompilationOptions.get_SourceReferenceResolver +Microsoft.CodeAnalysis.CompilationOptions.get_SpecificDiagnosticOptions +Microsoft.CodeAnalysis.CompilationOptions.get_StrongNameProvider +Microsoft.CodeAnalysis.CompilationOptions.get_SyntaxTreeOptionsProvider +Microsoft.CodeAnalysis.CompilationOptions.get_WarningLevel +Microsoft.CodeAnalysis.CompilationOptions.get_XmlReferenceResolver +Microsoft.CodeAnalysis.CompilationOptions.op_Equality(Microsoft.CodeAnalysis.CompilationOptions,Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.CompilationOptions.op_Inequality(Microsoft.CodeAnalysis.CompilationOptions,Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.CompilationOptions.set_AssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +Microsoft.CodeAnalysis.CompilationOptions.set_CheckOverflow(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.set_ConcurrentBuild(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.set_CryptoKeyContainer(System.String) +Microsoft.CodeAnalysis.CompilationOptions.set_CryptoKeyFile(System.String) +Microsoft.CodeAnalysis.CompilationOptions.set_CryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) +Microsoft.CodeAnalysis.CompilationOptions.set_DelaySign(System.Nullable{System.Boolean}) +Microsoft.CodeAnalysis.CompilationOptions.set_Deterministic(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.set_Features(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.CompilationOptions.set_GeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +Microsoft.CodeAnalysis.CompilationOptions.set_MainTypeName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.set_MetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +Microsoft.CodeAnalysis.CompilationOptions.set_MetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.set_ModuleName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.set_NullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) +Microsoft.CodeAnalysis.CompilationOptions.set_OptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +Microsoft.CodeAnalysis.CompilationOptions.set_OutputKind(Microsoft.CodeAnalysis.OutputKind) +Microsoft.CodeAnalysis.CompilationOptions.set_Platform(Microsoft.CodeAnalysis.Platform) +Microsoft.CodeAnalysis.CompilationOptions.set_PublicSign(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.set_ReportSuppressedDiagnostics(System.Boolean) +Microsoft.CodeAnalysis.CompilationOptions.set_ScriptClassName(System.String) +Microsoft.CodeAnalysis.CompilationOptions.set_SourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +Microsoft.CodeAnalysis.CompilationOptions.set_SpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.CompilationOptions.set_StrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +Microsoft.CodeAnalysis.CompilationOptions.set_SyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +Microsoft.CodeAnalysis.CompilationOptions.set_WarningLevel(System.Int32) +Microsoft.CodeAnalysis.CompilationOptions.set_XmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +Microsoft.CodeAnalysis.CompilationReference +Microsoft.CodeAnalysis.CompilationReference.Equals(Microsoft.CodeAnalysis.CompilationReference) +Microsoft.CodeAnalysis.CompilationReference.Equals(System.Object) +Microsoft.CodeAnalysis.CompilationReference.GetHashCode +Microsoft.CodeAnalysis.CompilationReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.CompilationReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.CompilationReference.WithEmbedInteropTypes(System.Boolean) +Microsoft.CodeAnalysis.CompilationReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.CompilationReference.get_Compilation +Microsoft.CodeAnalysis.CompilationReference.get_Display +Microsoft.CodeAnalysis.ControlFlowAnalysis +Microsoft.CodeAnalysis.ControlFlowAnalysis.#ctor +Microsoft.CodeAnalysis.ControlFlowAnalysis.get_EndPointIsReachable +Microsoft.CodeAnalysis.ControlFlowAnalysis.get_EntryPoints +Microsoft.CodeAnalysis.ControlFlowAnalysis.get_ExitPoints +Microsoft.CodeAnalysis.ControlFlowAnalysis.get_ReturnStatements +Microsoft.CodeAnalysis.ControlFlowAnalysis.get_StartPointIsReachable +Microsoft.CodeAnalysis.ControlFlowAnalysis.get_Succeeded +Microsoft.CodeAnalysis.CustomModifier +Microsoft.CodeAnalysis.CustomModifier.#ctor +Microsoft.CodeAnalysis.CustomModifier.get_IsOptional +Microsoft.CodeAnalysis.CustomModifier.get_Modifier +Microsoft.CodeAnalysis.DataFlowAnalysis +Microsoft.CodeAnalysis.DataFlowAnalysis.#ctor +Microsoft.CodeAnalysis.DataFlowAnalysis.get_AlwaysAssigned +Microsoft.CodeAnalysis.DataFlowAnalysis.get_Captured +Microsoft.CodeAnalysis.DataFlowAnalysis.get_CapturedInside +Microsoft.CodeAnalysis.DataFlowAnalysis.get_CapturedOutside +Microsoft.CodeAnalysis.DataFlowAnalysis.get_DataFlowsIn +Microsoft.CodeAnalysis.DataFlowAnalysis.get_DataFlowsOut +Microsoft.CodeAnalysis.DataFlowAnalysis.get_DefinitelyAssignedOnEntry +Microsoft.CodeAnalysis.DataFlowAnalysis.get_DefinitelyAssignedOnExit +Microsoft.CodeAnalysis.DataFlowAnalysis.get_ReadInside +Microsoft.CodeAnalysis.DataFlowAnalysis.get_ReadOutside +Microsoft.CodeAnalysis.DataFlowAnalysis.get_Succeeded +Microsoft.CodeAnalysis.DataFlowAnalysis.get_UnsafeAddressTaken +Microsoft.CodeAnalysis.DataFlowAnalysis.get_UsedLocalFunctions +Microsoft.CodeAnalysis.DataFlowAnalysis.get_VariablesDeclared +Microsoft.CodeAnalysis.DataFlowAnalysis.get_WrittenInside +Microsoft.CodeAnalysis.DataFlowAnalysis.get_WrittenOutside +Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer +Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.LoadFromXml(System.IO.Stream) +Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.get_Default +Microsoft.CodeAnalysis.Diagnostic +Microsoft.CodeAnalysis.Diagnostic.#ctor +Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) +Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) +Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Object[]) +Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) +Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Object[]) +Microsoft.CodeAnalysis.Diagnostic.Create(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.DiagnosticSeverity,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.Int32,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Generic.IEnumerable{System.String},System.Collections.Immutable.ImmutableDictionary{System.String,System.String}) +Microsoft.CodeAnalysis.Diagnostic.Create(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.DiagnosticSeverity,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.Int32,System.Boolean,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Generic.IEnumerable{System.String},System.Collections.Immutable.ImmutableDictionary{System.String,System.String}) +Microsoft.CodeAnalysis.Diagnostic.Equals(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostic.Equals(System.Object) +Microsoft.CodeAnalysis.Diagnostic.GetHashCode +Microsoft.CodeAnalysis.Diagnostic.GetMessage(System.IFormatProvider) +Microsoft.CodeAnalysis.Diagnostic.GetSuppressionInfo(Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.Diagnostic.ToString +Microsoft.CodeAnalysis.Diagnostic.get_AdditionalLocations +Microsoft.CodeAnalysis.Diagnostic.get_DefaultSeverity +Microsoft.CodeAnalysis.Diagnostic.get_Descriptor +Microsoft.CodeAnalysis.Diagnostic.get_Id +Microsoft.CodeAnalysis.Diagnostic.get_IsSuppressed +Microsoft.CodeAnalysis.Diagnostic.get_IsWarningAsError +Microsoft.CodeAnalysis.Diagnostic.get_Location +Microsoft.CodeAnalysis.Diagnostic.get_Properties +Microsoft.CodeAnalysis.Diagnostic.get_Severity +Microsoft.CodeAnalysis.Diagnostic.get_WarningLevel +Microsoft.CodeAnalysis.DiagnosticDescriptor +Microsoft.CodeAnalysis.DiagnosticDescriptor.#ctor(System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,Microsoft.CodeAnalysis.LocalizableString,System.String,System.String[]) +Microsoft.CodeAnalysis.DiagnosticDescriptor.#ctor(System.String,System.String,System.String,System.String,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.String,System.String,System.String[]) +Microsoft.CodeAnalysis.DiagnosticDescriptor.Equals(Microsoft.CodeAnalysis.DiagnosticDescriptor) +Microsoft.CodeAnalysis.DiagnosticDescriptor.Equals(System.Object) +Microsoft.CodeAnalysis.DiagnosticDescriptor.GetEffectiveSeverity(Microsoft.CodeAnalysis.CompilationOptions) +Microsoft.CodeAnalysis.DiagnosticDescriptor.GetHashCode +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Category +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_CustomTags +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_DefaultSeverity +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Description +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_HelpLinkUri +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Id +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_IsEnabledByDefault +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_MessageFormat +Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Title +Microsoft.CodeAnalysis.DiagnosticFormatter +Microsoft.CodeAnalysis.DiagnosticFormatter.#ctor +Microsoft.CodeAnalysis.DiagnosticFormatter.Format(Microsoft.CodeAnalysis.Diagnostic,System.IFormatProvider) +Microsoft.CodeAnalysis.DiagnosticSeverity +Microsoft.CodeAnalysis.DiagnosticSeverity.Error +Microsoft.CodeAnalysis.DiagnosticSeverity.Hidden +Microsoft.CodeAnalysis.DiagnosticSeverity.Info +Microsoft.CodeAnalysis.DiagnosticSeverity.Warning +Microsoft.CodeAnalysis.DiagnosticSeverity.value__ +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_AdditionalFile +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider`1 +Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.AdditionalText,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.AdditionalText}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.#ctor +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.ConfigureGeneratedCodeAnalysis(Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.EnableConcurrentExecution +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterAdditionalFileAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSemanticModelAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},Microsoft.CodeAnalysis.SymbolKind[]) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolKind}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext},Microsoft.CodeAnalysis.SymbolKind) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxTreeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.get_MinimumReportedSeverity +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.GetAllDiagnostics +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.GetAllDiagnostics(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer) +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_AdditionalFileDiagnostics +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_AnalyzerTelemetryInfo +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_Analyzers +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_CompilationDiagnostics +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_SemanticDiagnostics +Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_SyntaxDiagnostics +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.#ctor +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.TryGetValue(System.String,System.String@) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.get_KeyComparer +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.get_Keys +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.#ctor +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.GetOptions(Microsoft.CodeAnalysis.AdditionalText) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.GetOptions(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.get_GlobalOptions +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(System.Object) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAnalyzers(System.String) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAnalyzersForAllLanguages +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAssembly +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators(System.String) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGeneratorsForAllLanguages +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetHashCode +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.add_AnalyzerLoadFailed(System.EventHandler{Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs}) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_AssemblyLoader +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_Display +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_FullPath +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_Id +Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.remove_AnalyzerLoadFailed(System.EventHandler{Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs}) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference +Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.GetAnalyzers(System.String) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.GetAnalyzersForAllLanguages +Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_Display +Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_FullPath +Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_Id +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode,System.String,System.Exception,System.String) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.None +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesFramework +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesNewerCompiler +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.value__ +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_ErrorCode +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_Exception +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_Message +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_ReferencedCompilerVersion +Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_TypeName +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.Equals(System.Object) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.GetHashCode +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.WithAdditionalFiles(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.get_AdditionalFiles +Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.get_AnalyzerConfigOptionsProvider +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.#ctor +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetAnalyzers(System.String) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetAnalyzersForAllLanguages +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators(System.String) +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGeneratorsForAllLanguages +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_Display +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_FullPath +Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_Id +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_CodeBlock +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_OwningSymbol +Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_SemanticModel +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1 +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterCodeBlockEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterSyntaxNodeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{`0}) +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterSyntaxNodeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},`0[]) +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_CodeBlock +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_Options +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_OwningSymbol +Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_SemanticModel +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.#ctor(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.#ctor(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterAdditionalFileAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCompilationEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSemanticModelAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},Microsoft.CodeAnalysis.SymbolKind[]) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolKind}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext},Microsoft.CodeAnalysis.SymbolKind) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxTreeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.ClearAnalyzerState(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer}) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAllDiagnosticsAsync +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAllDiagnosticsAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerCompilationDiagnosticsAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerCompilationDiagnosticsAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerTelemetryInfoAsync(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetEffectiveDiagnostics(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Diagnostic},Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetEffectiveDiagnostics(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic},Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.IsDiagnosticAnalyzerSuppressed(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.CompilationOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic}) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_AnalysisOptions +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_Analyzers +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean,System.Boolean,System.Func{System.Exception,System.Boolean}) +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_AnalyzerExceptionFilter +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_ConcurrentAnalysis +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_LogAnalyzerExecutionTime +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_OnAnalyzerException +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_Options +Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_ReportSuppressedDiagnostics +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.#ctor +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.Equals(System.Object) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.GetHashCode +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.ToString +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.get_SupportedDiagnostics +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute.#ctor(System.String,System.String[]) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute.get_Languages +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor +Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.#ctor +Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.ReportSuppressions(Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext) +Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.get_SupportedDiagnostics +Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.get_SupportedSuppressions +Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags +Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.Analyze +Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.None +Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.ReportDiagnostics +Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.value__ +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.#ctor(Microsoft.CodeAnalysis.IOperation,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.GetControlFlowGraph +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_ContainingSymbol +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Operation +Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.IOperation},Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.GetControlFlowGraph(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_OperationBlocks +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_OwningSymbol +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.IOperation},Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.GetControlFlowGraph(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationBlockEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_OperationBlocks +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_OwningSymbol +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.#ctor(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_SemanticModel +Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider`1 +Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.Text.SourceText,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.Text.SourceText}) +Microsoft.CodeAnalysis.Diagnostics.Suppression +Microsoft.CodeAnalysis.Diagnostics.Suppression.Create(Microsoft.CodeAnalysis.SuppressionDescriptor,Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.Suppression.Equals(Microsoft.CodeAnalysis.Diagnostics.Suppression) +Microsoft.CodeAnalysis.Diagnostics.Suppression.Equals(System.Object) +Microsoft.CodeAnalysis.Diagnostics.Suppression.GetHashCode +Microsoft.CodeAnalysis.Diagnostics.Suppression.get_Descriptor +Microsoft.CodeAnalysis.Diagnostics.Suppression.get_SuppressedDiagnostic +Microsoft.CodeAnalysis.Diagnostics.Suppression.op_Equality(Microsoft.CodeAnalysis.Diagnostics.Suppression,Microsoft.CodeAnalysis.Diagnostics.Suppression) +Microsoft.CodeAnalysis.Diagnostics.Suppression.op_Inequality(Microsoft.CodeAnalysis.Diagnostics.Suppression,Microsoft.CodeAnalysis.Diagnostics.Suppression) +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.ReportSuppression(Microsoft.CodeAnalysis.Diagnostics.Suppression) +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_ReportedDiagnostics +Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo +Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_Attribute +Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_Id +Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_ProgrammaticSuppressions +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.#ctor(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Symbol +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.#ctor(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSymbolEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Symbol +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Compilation +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_ContainingSymbol +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_FilterTree +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Node +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_SemanticModel +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_CancellationToken +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_FilterSpan +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_IsGeneratedCode +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_Options +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_Tree +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider`1 +Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.SyntaxTree,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.SyntaxTree}) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.#ctor +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_AdditionalFileActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockEndActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockStartActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationEndActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationStartActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_Concurrent +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_ExecutionTime +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockEndActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockStartActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SemanticModelActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SuppressionActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolEndActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolStartActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SyntaxNodeActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SyntaxTreeActionsCount +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_AdditionalFileActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockEndActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockStartActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationEndActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationStartActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_Concurrent(System.Boolean) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_ExecutionTime(System.TimeSpan) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockEndActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockStartActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SemanticModelActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SuppressionActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolEndActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolStartActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SyntaxNodeActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SyntaxTreeActionsCount(System.Int32) +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.#ctor(System.String) +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.GetAnalyzers(System.String) +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.GetAnalyzersForAllLanguages +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_Display +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_FullPath +Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_Id +Microsoft.CodeAnalysis.DllImportData +Microsoft.CodeAnalysis.DllImportData.get_BestFitMapping +Microsoft.CodeAnalysis.DllImportData.get_CallingConvention +Microsoft.CodeAnalysis.DllImportData.get_CharacterSet +Microsoft.CodeAnalysis.DllImportData.get_EntryPointName +Microsoft.CodeAnalysis.DllImportData.get_ExactSpelling +Microsoft.CodeAnalysis.DllImportData.get_ModuleName +Microsoft.CodeAnalysis.DllImportData.get_SetLastError +Microsoft.CodeAnalysis.DllImportData.get_ThrowOnUnmappableCharacter +Microsoft.CodeAnalysis.DocumentationCommentId +Microsoft.CodeAnalysis.DocumentationCommentId.CreateDeclarationId(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.DocumentationCommentId.CreateReferenceId(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.DocumentationCommentId.GetFirstSymbolForDeclarationId(System.String,Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.DocumentationCommentId.GetFirstSymbolForReferenceId(System.String,Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.DocumentationCommentId.GetSymbolsForDeclarationId(System.String,Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.DocumentationCommentId.GetSymbolsForReferenceId(System.String,Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.DocumentationMode +Microsoft.CodeAnalysis.DocumentationMode.Diagnose +Microsoft.CodeAnalysis.DocumentationMode.None +Microsoft.CodeAnalysis.DocumentationMode.Parse +Microsoft.CodeAnalysis.DocumentationMode.value__ +Microsoft.CodeAnalysis.DocumentationProvider +Microsoft.CodeAnalysis.DocumentationProvider.#ctor +Microsoft.CodeAnalysis.DocumentationProvider.Equals(System.Object) +Microsoft.CodeAnalysis.DocumentationProvider.GetDocumentationForSymbol(System.String,System.Globalization.CultureInfo,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.DocumentationProvider.GetHashCode +Microsoft.CodeAnalysis.DocumentationProvider.get_Default +Microsoft.CodeAnalysis.EmbeddedText +Microsoft.CodeAnalysis.EmbeddedText.FromBytes(System.String,System.ArraySegment{System.Byte},Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +Microsoft.CodeAnalysis.EmbeddedText.FromSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.EmbeddedText.FromStream(System.String,System.IO.Stream,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +Microsoft.CodeAnalysis.EmbeddedText.get_Checksum +Microsoft.CodeAnalysis.EmbeddedText.get_ChecksumAlgorithm +Microsoft.CodeAnalysis.EmbeddedText.get_FilePath +Microsoft.CodeAnalysis.ErrorLogOptions +Microsoft.CodeAnalysis.ErrorLogOptions.#ctor(System.String,Microsoft.CodeAnalysis.SarifVersion) +Microsoft.CodeAnalysis.ErrorLogOptions.get_Path +Microsoft.CodeAnalysis.ErrorLogOptions.get_SarifVersion +Microsoft.CodeAnalysis.FileLinePositionSpan +Microsoft.CodeAnalysis.FileLinePositionSpan.#ctor(System.String,Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.FileLinePositionSpan.#ctor(System.String,Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.FileLinePositionSpan.Equals(Microsoft.CodeAnalysis.FileLinePositionSpan) +Microsoft.CodeAnalysis.FileLinePositionSpan.Equals(System.Object) +Microsoft.CodeAnalysis.FileLinePositionSpan.GetHashCode +Microsoft.CodeAnalysis.FileLinePositionSpan.ToString +Microsoft.CodeAnalysis.FileLinePositionSpan.get_EndLinePosition +Microsoft.CodeAnalysis.FileLinePositionSpan.get_HasMappedPath +Microsoft.CodeAnalysis.FileLinePositionSpan.get_IsValid +Microsoft.CodeAnalysis.FileLinePositionSpan.get_Path +Microsoft.CodeAnalysis.FileLinePositionSpan.get_Span +Microsoft.CodeAnalysis.FileLinePositionSpan.get_StartLinePosition +Microsoft.CodeAnalysis.FileLinePositionSpan.op_Equality(Microsoft.CodeAnalysis.FileLinePositionSpan,Microsoft.CodeAnalysis.FileLinePositionSpan) +Microsoft.CodeAnalysis.FileLinePositionSpan.op_Inequality(Microsoft.CodeAnalysis.FileLinePositionSpan,Microsoft.CodeAnalysis.FileLinePositionSpan) +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_BranchValue +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_ConditionKind +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_ConditionalSuccessor +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_EnclosingRegion +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_FallThroughSuccessor +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_IsReachable +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Kind +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Operations +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Ordinal +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Predecessors +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Block +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Entry +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Exit +Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.value__ +Microsoft.CodeAnalysis.FlowAnalysis.CaptureId +Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.Equals(Microsoft.CodeAnalysis.FlowAnalysis.CaptureId) +Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.Equals(System.Object) +Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.GetHashCode +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Destination +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_EnteringRegions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_FinallyRegions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_IsConditionalSuccessor +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_LeavingRegions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Semantics +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Source +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Error +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.None +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.ProgramTermination +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Regular +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Rethrow +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Return +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.StructuredExceptionHandling +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Throw +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.value__ +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.None +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.WhenFalse +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.WhenTrue +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.value__ +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IAttributeOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IBlockOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.GetAnonymousFunctionControlFlowGraph(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.GetLocalFunctionControlFlowGraph(Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Blocks +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_LocalFunctions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_OriginalOperation +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Parent +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Root +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions.GetAnonymousFunctionControlFlowGraphInScope(Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph,Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions.GetLocalFunctionControlFlowGraphInScope(Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph,Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_CaptureIds +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_EnclosingRegion +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_ExceptionType +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_FirstBlockOrdinal +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_Kind +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_LastBlockOrdinal +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_LocalFunctions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_Locals +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_NestedRegions +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Catch +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.ErroneousBody +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Filter +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.FilterAndHandler +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Finally +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.LocalLifetime +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Root +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.StaticLocalInitializer +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Try +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.TryAndCatch +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.TryAndFinally +Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.value__ +Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation +Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation +Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation.get_Symbol +Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation +Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation.get_Id +Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation.get_Value +Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation +Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation.get_Id +Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation.get_IsInitialization +Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation +Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation.get_Operand +Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation +Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation.get_Local +Microsoft.CodeAnalysis.GeneratedKind +Microsoft.CodeAnalysis.GeneratedKind.MarkedGenerated +Microsoft.CodeAnalysis.GeneratedKind.NotGenerated +Microsoft.CodeAnalysis.GeneratedKind.Unknown +Microsoft.CodeAnalysis.GeneratedKind.value__ +Microsoft.CodeAnalysis.GeneratedSourceResult +Microsoft.CodeAnalysis.GeneratedSourceResult.get_HintName +Microsoft.CodeAnalysis.GeneratedSourceResult.get_SourceText +Microsoft.CodeAnalysis.GeneratedSourceResult.get_SyntaxTree +Microsoft.CodeAnalysis.GeneratorAttribute +Microsoft.CodeAnalysis.GeneratorAttribute.#ctor +Microsoft.CodeAnalysis.GeneratorAttribute.#ctor(System.String,System.String[]) +Microsoft.CodeAnalysis.GeneratorAttribute.get_Languages +Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext +Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_Attributes +Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_SemanticModel +Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_TargetNode +Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_TargetSymbol +Microsoft.CodeAnalysis.GeneratorDriver +Microsoft.CodeAnalysis.GeneratorDriver.AddAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +Microsoft.CodeAnalysis.GeneratorDriver.AddGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) +Microsoft.CodeAnalysis.GeneratorDriver.GetRunResult +Microsoft.CodeAnalysis.GeneratorDriver.GetTimingInfo +Microsoft.CodeAnalysis.GeneratorDriver.RemoveAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +Microsoft.CodeAnalysis.GeneratorDriver.RemoveGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) +Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalText(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.AdditionalText) +Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +Microsoft.CodeAnalysis.GeneratorDriver.ReplaceGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) +Microsoft.CodeAnalysis.GeneratorDriver.RunGenerators(Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.GeneratorDriver.RunGenerators(Microsoft.CodeAnalysis.Compilation,System.Func{Microsoft.CodeAnalysis.GeneratorFilterContext,System.Boolean},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.GeneratorDriver.RunGenerators(Microsoft.CodeAnalysis.Compilation,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.GeneratorDriver.RunGeneratorsAndUpdateCompilation(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Compilation@,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic}@,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedAnalyzerConfigOptions(Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) +Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedParseOptions(Microsoft.CodeAnalysis.ParseOptions) +Microsoft.CodeAnalysis.GeneratorDriverOptions +Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind) +Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind,System.Boolean) +Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind,System.Boolean,System.String) +Microsoft.CodeAnalysis.GeneratorDriverOptions.DisabledOutputs +Microsoft.CodeAnalysis.GeneratorDriverOptions.TrackIncrementalGeneratorSteps +Microsoft.CodeAnalysis.GeneratorDriverOptions.get_BaseDirectory +Microsoft.CodeAnalysis.GeneratorDriverRunResult +Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_Diagnostics +Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_GeneratedTrees +Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_Results +Microsoft.CodeAnalysis.GeneratorDriverTimingInfo +Microsoft.CodeAnalysis.GeneratorDriverTimingInfo.get_ElapsedTime +Microsoft.CodeAnalysis.GeneratorDriverTimingInfo.get_GeneratorTimes +Microsoft.CodeAnalysis.GeneratorExecutionContext +Microsoft.CodeAnalysis.GeneratorExecutionContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.GeneratorExecutionContext.AddSource(System.String,System.String) +Microsoft.CodeAnalysis.GeneratorExecutionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_AdditionalFiles +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_AnalyzerConfigOptions +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_CancellationToken +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_Compilation +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_ParseOptions +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_SyntaxContextReceiver +Microsoft.CodeAnalysis.GeneratorExecutionContext.get_SyntaxReceiver +Microsoft.CodeAnalysis.GeneratorExtensions +Microsoft.CodeAnalysis.GeneratorExtensions.AsIncrementalGenerator(Microsoft.CodeAnalysis.ISourceGenerator) +Microsoft.CodeAnalysis.GeneratorExtensions.AsSourceGenerator(Microsoft.CodeAnalysis.IIncrementalGenerator) +Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(Microsoft.CodeAnalysis.IIncrementalGenerator) +Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(Microsoft.CodeAnalysis.ISourceGenerator) +Microsoft.CodeAnalysis.GeneratorFilterContext +Microsoft.CodeAnalysis.GeneratorFilterContext.get_CancellationToken +Microsoft.CodeAnalysis.GeneratorFilterContext.get_Generator +Microsoft.CodeAnalysis.GeneratorInitializationContext +Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForPostInitialization(System.Action{Microsoft.CodeAnalysis.GeneratorPostInitializationContext}) +Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxContextReceiverCreator) +Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxReceiverCreator) +Microsoft.CodeAnalysis.GeneratorInitializationContext.get_CancellationToken +Microsoft.CodeAnalysis.GeneratorPostInitializationContext +Microsoft.CodeAnalysis.GeneratorPostInitializationContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.GeneratorPostInitializationContext.AddSource(System.String,System.String) +Microsoft.CodeAnalysis.GeneratorPostInitializationContext.get_CancellationToken +Microsoft.CodeAnalysis.GeneratorRunResult +Microsoft.CodeAnalysis.GeneratorRunResult.get_Diagnostics +Microsoft.CodeAnalysis.GeneratorRunResult.get_Exception +Microsoft.CodeAnalysis.GeneratorRunResult.get_GeneratedSources +Microsoft.CodeAnalysis.GeneratorRunResult.get_Generator +Microsoft.CodeAnalysis.GeneratorRunResult.get_HostOutputs +Microsoft.CodeAnalysis.GeneratorRunResult.get_TrackedOutputSteps +Microsoft.CodeAnalysis.GeneratorRunResult.get_TrackedSteps +Microsoft.CodeAnalysis.GeneratorSyntaxContext +Microsoft.CodeAnalysis.GeneratorSyntaxContext.get_Node +Microsoft.CodeAnalysis.GeneratorSyntaxContext.get_SemanticModel +Microsoft.CodeAnalysis.GeneratorTimingInfo +Microsoft.CodeAnalysis.GeneratorTimingInfo.get_ElapsedTime +Microsoft.CodeAnalysis.GeneratorTimingInfo.get_Generator +Microsoft.CodeAnalysis.HostOutputProductionContext +Microsoft.CodeAnalysis.HostOutputProductionContext.AddOutput(System.String,System.Object) +Microsoft.CodeAnalysis.HostOutputProductionContext.get_CancellationToken +Microsoft.CodeAnalysis.IAliasSymbol +Microsoft.CodeAnalysis.IAliasSymbol.get_Target +Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader +Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader.AddDependencyLocation(System.String) +Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader.LoadFromPath(System.String) +Microsoft.CodeAnalysis.IArrayTypeSymbol +Microsoft.CodeAnalysis.IArrayTypeSymbol.Equals(Microsoft.CodeAnalysis.IArrayTypeSymbol) +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_CustomModifiers +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_ElementNullableAnnotation +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_ElementType +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_IsSZArray +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_LowerBounds +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_Rank +Microsoft.CodeAnalysis.IArrayTypeSymbol.get_Sizes +Microsoft.CodeAnalysis.IAssemblySymbol +Microsoft.CodeAnalysis.IAssemblySymbol.GetForwardedTypes +Microsoft.CodeAnalysis.IAssemblySymbol.GetMetadata +Microsoft.CodeAnalysis.IAssemblySymbol.GetTypeByMetadataName(System.String) +Microsoft.CodeAnalysis.IAssemblySymbol.GivesAccessTo(Microsoft.CodeAnalysis.IAssemblySymbol) +Microsoft.CodeAnalysis.IAssemblySymbol.ResolveForwardedType(System.String) +Microsoft.CodeAnalysis.IAssemblySymbol.get_GlobalNamespace +Microsoft.CodeAnalysis.IAssemblySymbol.get_Identity +Microsoft.CodeAnalysis.IAssemblySymbol.get_IsInteractive +Microsoft.CodeAnalysis.IAssemblySymbol.get_MightContainExtensionMethods +Microsoft.CodeAnalysis.IAssemblySymbol.get_Modules +Microsoft.CodeAnalysis.IAssemblySymbol.get_NamespaceNames +Microsoft.CodeAnalysis.IAssemblySymbol.get_TypeNames +Microsoft.CodeAnalysis.ICompilationUnitSyntax +Microsoft.CodeAnalysis.ICompilationUnitSyntax.get_EndOfFileToken +Microsoft.CodeAnalysis.IDiscardSymbol +Microsoft.CodeAnalysis.IDiscardSymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.IDiscardSymbol.get_Type +Microsoft.CodeAnalysis.IDynamicTypeSymbol +Microsoft.CodeAnalysis.IErrorTypeSymbol +Microsoft.CodeAnalysis.IErrorTypeSymbol.get_CandidateReason +Microsoft.CodeAnalysis.IErrorTypeSymbol.get_CandidateSymbols +Microsoft.CodeAnalysis.IEventSymbol +Microsoft.CodeAnalysis.IEventSymbol.get_AddMethod +Microsoft.CodeAnalysis.IEventSymbol.get_ExplicitInterfaceImplementations +Microsoft.CodeAnalysis.IEventSymbol.get_IsWindowsRuntimeEvent +Microsoft.CodeAnalysis.IEventSymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.IEventSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.IEventSymbol.get_OverriddenEvent +Microsoft.CodeAnalysis.IEventSymbol.get_RaiseMethod +Microsoft.CodeAnalysis.IEventSymbol.get_RemoveMethod +Microsoft.CodeAnalysis.IEventSymbol.get_Type +Microsoft.CodeAnalysis.IFieldSymbol +Microsoft.CodeAnalysis.IFieldSymbol.get_AssociatedSymbol +Microsoft.CodeAnalysis.IFieldSymbol.get_ConstantValue +Microsoft.CodeAnalysis.IFieldSymbol.get_CorrespondingTupleField +Microsoft.CodeAnalysis.IFieldSymbol.get_CustomModifiers +Microsoft.CodeAnalysis.IFieldSymbol.get_FixedSize +Microsoft.CodeAnalysis.IFieldSymbol.get_HasConstantValue +Microsoft.CodeAnalysis.IFieldSymbol.get_IsConst +Microsoft.CodeAnalysis.IFieldSymbol.get_IsExplicitlyNamedTupleElement +Microsoft.CodeAnalysis.IFieldSymbol.get_IsFixedSizeBuffer +Microsoft.CodeAnalysis.IFieldSymbol.get_IsReadOnly +Microsoft.CodeAnalysis.IFieldSymbol.get_IsRequired +Microsoft.CodeAnalysis.IFieldSymbol.get_IsVolatile +Microsoft.CodeAnalysis.IFieldSymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.IFieldSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.IFieldSymbol.get_RefCustomModifiers +Microsoft.CodeAnalysis.IFieldSymbol.get_RefKind +Microsoft.CodeAnalysis.IFieldSymbol.get_Type +Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol +Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol.get_Signature +Microsoft.CodeAnalysis.IImportScope +Microsoft.CodeAnalysis.IImportScope.get_Aliases +Microsoft.CodeAnalysis.IImportScope.get_ExternAliases +Microsoft.CodeAnalysis.IImportScope.get_Imports +Microsoft.CodeAnalysis.IImportScope.get_XmlNamespaces +Microsoft.CodeAnalysis.IIncrementalGenerator +Microsoft.CodeAnalysis.IIncrementalGenerator.Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext) +Microsoft.CodeAnalysis.ILabelSymbol +Microsoft.CodeAnalysis.ILabelSymbol.get_ContainingMethod +Microsoft.CodeAnalysis.ILocalSymbol +Microsoft.CodeAnalysis.ILocalSymbol.get_ConstantValue +Microsoft.CodeAnalysis.ILocalSymbol.get_HasConstantValue +Microsoft.CodeAnalysis.ILocalSymbol.get_IsConst +Microsoft.CodeAnalysis.ILocalSymbol.get_IsFixed +Microsoft.CodeAnalysis.ILocalSymbol.get_IsForEach +Microsoft.CodeAnalysis.ILocalSymbol.get_IsFunctionValue +Microsoft.CodeAnalysis.ILocalSymbol.get_IsRef +Microsoft.CodeAnalysis.ILocalSymbol.get_IsUsing +Microsoft.CodeAnalysis.ILocalSymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.ILocalSymbol.get_RefKind +Microsoft.CodeAnalysis.ILocalSymbol.get_ScopedKind +Microsoft.CodeAnalysis.ILocalSymbol.get_Type +Microsoft.CodeAnalysis.IMethodSymbol +Microsoft.CodeAnalysis.IMethodSymbol.Construct(Microsoft.CodeAnalysis.ITypeSymbol[]) +Microsoft.CodeAnalysis.IMethodSymbol.Construct(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.IMethodSymbol.GetDllImportData +Microsoft.CodeAnalysis.IMethodSymbol.GetReturnTypeAttributes +Microsoft.CodeAnalysis.IMethodSymbol.GetTypeInferredDuringReduction(Microsoft.CodeAnalysis.ITypeParameterSymbol) +Microsoft.CodeAnalysis.IMethodSymbol.ReduceExtensionMethod(Microsoft.CodeAnalysis.ITypeSymbol) +Microsoft.CodeAnalysis.IMethodSymbol.get_Arity +Microsoft.CodeAnalysis.IMethodSymbol.get_AssociatedAnonymousDelegate +Microsoft.CodeAnalysis.IMethodSymbol.get_AssociatedSymbol +Microsoft.CodeAnalysis.IMethodSymbol.get_CallingConvention +Microsoft.CodeAnalysis.IMethodSymbol.get_ConstructedFrom +Microsoft.CodeAnalysis.IMethodSymbol.get_ExplicitInterfaceImplementations +Microsoft.CodeAnalysis.IMethodSymbol.get_HidesBaseMethodsByName +Microsoft.CodeAnalysis.IMethodSymbol.get_IsAsync +Microsoft.CodeAnalysis.IMethodSymbol.get_IsCheckedBuiltin +Microsoft.CodeAnalysis.IMethodSymbol.get_IsConditional +Microsoft.CodeAnalysis.IMethodSymbol.get_IsExtensionMethod +Microsoft.CodeAnalysis.IMethodSymbol.get_IsGenericMethod +Microsoft.CodeAnalysis.IMethodSymbol.get_IsInitOnly +Microsoft.CodeAnalysis.IMethodSymbol.get_IsPartialDefinition +Microsoft.CodeAnalysis.IMethodSymbol.get_IsReadOnly +Microsoft.CodeAnalysis.IMethodSymbol.get_IsVararg +Microsoft.CodeAnalysis.IMethodSymbol.get_MethodImplementationFlags +Microsoft.CodeAnalysis.IMethodSymbol.get_MethodKind +Microsoft.CodeAnalysis.IMethodSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.IMethodSymbol.get_OverriddenMethod +Microsoft.CodeAnalysis.IMethodSymbol.get_Parameters +Microsoft.CodeAnalysis.IMethodSymbol.get_PartialDefinitionPart +Microsoft.CodeAnalysis.IMethodSymbol.get_PartialImplementationPart +Microsoft.CodeAnalysis.IMethodSymbol.get_ReceiverNullableAnnotation +Microsoft.CodeAnalysis.IMethodSymbol.get_ReceiverType +Microsoft.CodeAnalysis.IMethodSymbol.get_ReducedFrom +Microsoft.CodeAnalysis.IMethodSymbol.get_RefCustomModifiers +Microsoft.CodeAnalysis.IMethodSymbol.get_RefKind +Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnNullableAnnotation +Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnType +Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnTypeCustomModifiers +Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsByRef +Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsByRefReadonly +Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsVoid +Microsoft.CodeAnalysis.IMethodSymbol.get_TypeArgumentNullableAnnotations +Microsoft.CodeAnalysis.IMethodSymbol.get_TypeArguments +Microsoft.CodeAnalysis.IMethodSymbol.get_TypeParameters +Microsoft.CodeAnalysis.IMethodSymbol.get_UnmanagedCallingConventionTypes +Microsoft.CodeAnalysis.IModuleSymbol +Microsoft.CodeAnalysis.IModuleSymbol.GetMetadata +Microsoft.CodeAnalysis.IModuleSymbol.GetModuleNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +Microsoft.CodeAnalysis.IModuleSymbol.get_GlobalNamespace +Microsoft.CodeAnalysis.IModuleSymbol.get_ReferencedAssemblies +Microsoft.CodeAnalysis.IModuleSymbol.get_ReferencedAssemblySymbols +Microsoft.CodeAnalysis.INamedTypeSymbol +Microsoft.CodeAnalysis.INamedTypeSymbol.Construct(Microsoft.CodeAnalysis.ITypeSymbol[]) +Microsoft.CodeAnalysis.INamedTypeSymbol.Construct(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +Microsoft.CodeAnalysis.INamedTypeSymbol.ConstructUnboundGenericType +Microsoft.CodeAnalysis.INamedTypeSymbol.GetTypeArgumentCustomModifiers(System.Int32) +Microsoft.CodeAnalysis.INamedTypeSymbol.get_Arity +Microsoft.CodeAnalysis.INamedTypeSymbol.get_AssociatedSymbol +Microsoft.CodeAnalysis.INamedTypeSymbol.get_ConstructedFrom +Microsoft.CodeAnalysis.INamedTypeSymbol.get_Constructors +Microsoft.CodeAnalysis.INamedTypeSymbol.get_DelegateInvokeMethod +Microsoft.CodeAnalysis.INamedTypeSymbol.get_EnumUnderlyingType +Microsoft.CodeAnalysis.INamedTypeSymbol.get_InstanceConstructors +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsComImport +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsFileLocal +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsGenericType +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsImplicitClass +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsScriptClass +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsSerializable +Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsUnboundGenericType +Microsoft.CodeAnalysis.INamedTypeSymbol.get_MemberNames +Microsoft.CodeAnalysis.INamedTypeSymbol.get_MightContainExtensionMethods +Microsoft.CodeAnalysis.INamedTypeSymbol.get_NativeIntegerUnderlyingType +Microsoft.CodeAnalysis.INamedTypeSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.INamedTypeSymbol.get_StaticConstructors +Microsoft.CodeAnalysis.INamedTypeSymbol.get_TupleElements +Microsoft.CodeAnalysis.INamedTypeSymbol.get_TupleUnderlyingType +Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeArgumentNullableAnnotations +Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeArguments +Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeParameters +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetMembers +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetMembers(System.String) +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers(System.String) +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers(System.String,System.Int32) +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.get_IsNamespace +Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.get_IsType +Microsoft.CodeAnalysis.INamespaceSymbol +Microsoft.CodeAnalysis.INamespaceSymbol.GetMembers +Microsoft.CodeAnalysis.INamespaceSymbol.GetMembers(System.String) +Microsoft.CodeAnalysis.INamespaceSymbol.GetNamespaceMembers +Microsoft.CodeAnalysis.INamespaceSymbol.get_ConstituentNamespaces +Microsoft.CodeAnalysis.INamespaceSymbol.get_ContainingCompilation +Microsoft.CodeAnalysis.INamespaceSymbol.get_IsGlobalNamespace +Microsoft.CodeAnalysis.INamespaceSymbol.get_NamespaceKind +Microsoft.CodeAnalysis.IOperation +Microsoft.CodeAnalysis.IOperation.Accept(Microsoft.CodeAnalysis.Operations.OperationVisitor) +Microsoft.CodeAnalysis.IOperation.Accept``2(Microsoft.CodeAnalysis.Operations.OperationVisitor{``0,``1},``0) +Microsoft.CodeAnalysis.IOperation.OperationList +Microsoft.CodeAnalysis.IOperation.OperationList.Any +Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator +Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.MoveNext +Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.Reset +Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.get_Current +Microsoft.CodeAnalysis.IOperation.OperationList.First +Microsoft.CodeAnalysis.IOperation.OperationList.GetEnumerator +Microsoft.CodeAnalysis.IOperation.OperationList.Last +Microsoft.CodeAnalysis.IOperation.OperationList.Reverse +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.MoveNext +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.Reset +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.get_Current +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.GetEnumerator +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.ToImmutableArray +Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.get_Count +Microsoft.CodeAnalysis.IOperation.OperationList.ToImmutableArray +Microsoft.CodeAnalysis.IOperation.OperationList.get_Count +Microsoft.CodeAnalysis.IOperation.get_ChildOperations +Microsoft.CodeAnalysis.IOperation.get_Children +Microsoft.CodeAnalysis.IOperation.get_ConstantValue +Microsoft.CodeAnalysis.IOperation.get_IsImplicit +Microsoft.CodeAnalysis.IOperation.get_Kind +Microsoft.CodeAnalysis.IOperation.get_Language +Microsoft.CodeAnalysis.IOperation.get_Parent +Microsoft.CodeAnalysis.IOperation.get_SemanticModel +Microsoft.CodeAnalysis.IOperation.get_Syntax +Microsoft.CodeAnalysis.IOperation.get_Type +Microsoft.CodeAnalysis.IParameterSymbol +Microsoft.CodeAnalysis.IParameterSymbol.get_CustomModifiers +Microsoft.CodeAnalysis.IParameterSymbol.get_ExplicitDefaultValue +Microsoft.CodeAnalysis.IParameterSymbol.get_HasExplicitDefaultValue +Microsoft.CodeAnalysis.IParameterSymbol.get_IsDiscard +Microsoft.CodeAnalysis.IParameterSymbol.get_IsOptional +Microsoft.CodeAnalysis.IParameterSymbol.get_IsParams +Microsoft.CodeAnalysis.IParameterSymbol.get_IsParamsArray +Microsoft.CodeAnalysis.IParameterSymbol.get_IsParamsCollection +Microsoft.CodeAnalysis.IParameterSymbol.get_IsThis +Microsoft.CodeAnalysis.IParameterSymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.IParameterSymbol.get_Ordinal +Microsoft.CodeAnalysis.IParameterSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.IParameterSymbol.get_RefCustomModifiers +Microsoft.CodeAnalysis.IParameterSymbol.get_RefKind +Microsoft.CodeAnalysis.IParameterSymbol.get_ScopedKind +Microsoft.CodeAnalysis.IParameterSymbol.get_Type +Microsoft.CodeAnalysis.IPointerTypeSymbol +Microsoft.CodeAnalysis.IPointerTypeSymbol.get_CustomModifiers +Microsoft.CodeAnalysis.IPointerTypeSymbol.get_PointedAtType +Microsoft.CodeAnalysis.IPreprocessingSymbol +Microsoft.CodeAnalysis.IPropertySymbol +Microsoft.CodeAnalysis.IPropertySymbol.get_ExplicitInterfaceImplementations +Microsoft.CodeAnalysis.IPropertySymbol.get_GetMethod +Microsoft.CodeAnalysis.IPropertySymbol.get_IsIndexer +Microsoft.CodeAnalysis.IPropertySymbol.get_IsPartialDefinition +Microsoft.CodeAnalysis.IPropertySymbol.get_IsReadOnly +Microsoft.CodeAnalysis.IPropertySymbol.get_IsRequired +Microsoft.CodeAnalysis.IPropertySymbol.get_IsWithEvents +Microsoft.CodeAnalysis.IPropertySymbol.get_IsWriteOnly +Microsoft.CodeAnalysis.IPropertySymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.IPropertySymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.IPropertySymbol.get_OverriddenProperty +Microsoft.CodeAnalysis.IPropertySymbol.get_Parameters +Microsoft.CodeAnalysis.IPropertySymbol.get_PartialDefinitionPart +Microsoft.CodeAnalysis.IPropertySymbol.get_PartialImplementationPart +Microsoft.CodeAnalysis.IPropertySymbol.get_RefCustomModifiers +Microsoft.CodeAnalysis.IPropertySymbol.get_RefKind +Microsoft.CodeAnalysis.IPropertySymbol.get_ReturnsByRef +Microsoft.CodeAnalysis.IPropertySymbol.get_ReturnsByRefReadonly +Microsoft.CodeAnalysis.IPropertySymbol.get_SetMethod +Microsoft.CodeAnalysis.IPropertySymbol.get_Type +Microsoft.CodeAnalysis.IPropertySymbol.get_TypeCustomModifiers +Microsoft.CodeAnalysis.IRangeVariableSymbol +Microsoft.CodeAnalysis.ISkippedTokensTriviaSyntax +Microsoft.CodeAnalysis.ISkippedTokensTriviaSyntax.get_Tokens +Microsoft.CodeAnalysis.ISourceAssemblySymbol +Microsoft.CodeAnalysis.ISourceAssemblySymbol.get_Compilation +Microsoft.CodeAnalysis.ISourceGenerator +Microsoft.CodeAnalysis.ISourceGenerator.Execute(Microsoft.CodeAnalysis.GeneratorExecutionContext) +Microsoft.CodeAnalysis.ISourceGenerator.Initialize(Microsoft.CodeAnalysis.GeneratorInitializationContext) +Microsoft.CodeAnalysis.IStructuredTriviaSyntax +Microsoft.CodeAnalysis.IStructuredTriviaSyntax.get_ParentTrivia +Microsoft.CodeAnalysis.ISymbol +Microsoft.CodeAnalysis.ISymbol.Accept(Microsoft.CodeAnalysis.SymbolVisitor) +Microsoft.CodeAnalysis.ISymbol.Accept``1(Microsoft.CodeAnalysis.SymbolVisitor{``0}) +Microsoft.CodeAnalysis.ISymbol.Accept``2(Microsoft.CodeAnalysis.SymbolVisitor{``0,``1},``0) +Microsoft.CodeAnalysis.ISymbol.Equals(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolEqualityComparer) +Microsoft.CodeAnalysis.ISymbol.GetAttributes +Microsoft.CodeAnalysis.ISymbol.GetDocumentationCommentId +Microsoft.CodeAnalysis.ISymbol.GetDocumentationCommentXml(System.Globalization.CultureInfo,System.Boolean,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.ISymbol.ToDisplayParts(Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ISymbol.ToDisplayString(Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ISymbol.ToMinimalDisplayParts(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ISymbol.ToMinimalDisplayString(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ISymbol.get_CanBeReferencedByName +Microsoft.CodeAnalysis.ISymbol.get_ContainingAssembly +Microsoft.CodeAnalysis.ISymbol.get_ContainingModule +Microsoft.CodeAnalysis.ISymbol.get_ContainingNamespace +Microsoft.CodeAnalysis.ISymbol.get_ContainingSymbol +Microsoft.CodeAnalysis.ISymbol.get_ContainingType +Microsoft.CodeAnalysis.ISymbol.get_DeclaredAccessibility +Microsoft.CodeAnalysis.ISymbol.get_DeclaringSyntaxReferences +Microsoft.CodeAnalysis.ISymbol.get_HasUnsupportedMetadata +Microsoft.CodeAnalysis.ISymbol.get_IsAbstract +Microsoft.CodeAnalysis.ISymbol.get_IsDefinition +Microsoft.CodeAnalysis.ISymbol.get_IsExtern +Microsoft.CodeAnalysis.ISymbol.get_IsImplicitlyDeclared +Microsoft.CodeAnalysis.ISymbol.get_IsOverride +Microsoft.CodeAnalysis.ISymbol.get_IsSealed +Microsoft.CodeAnalysis.ISymbol.get_IsStatic +Microsoft.CodeAnalysis.ISymbol.get_IsVirtual +Microsoft.CodeAnalysis.ISymbol.get_Kind +Microsoft.CodeAnalysis.ISymbol.get_Language +Microsoft.CodeAnalysis.ISymbol.get_Locations +Microsoft.CodeAnalysis.ISymbol.get_MetadataName +Microsoft.CodeAnalysis.ISymbol.get_MetadataToken +Microsoft.CodeAnalysis.ISymbol.get_Name +Microsoft.CodeAnalysis.ISymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.ISymbolExtensions +Microsoft.CodeAnalysis.ISymbolExtensions.GetConstructedReducedFrom(Microsoft.CodeAnalysis.IMethodSymbol) +Microsoft.CodeAnalysis.ISyntaxContextReceiver +Microsoft.CodeAnalysis.ISyntaxContextReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.GeneratorSyntaxContext) +Microsoft.CodeAnalysis.ISyntaxReceiver +Microsoft.CodeAnalysis.ISyntaxReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.ITypeParameterSymbol +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_AllowsRefLikeType +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ConstraintNullableAnnotations +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ConstraintTypes +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_DeclaringMethod +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_DeclaringType +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasConstructorConstraint +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasNotNullConstraint +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasReferenceTypeConstraint +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasUnmanagedTypeConstraint +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasValueTypeConstraint +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_Ordinal +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ReducedFrom +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ReferenceTypeConstraintNullableAnnotation +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_TypeParameterKind +Microsoft.CodeAnalysis.ITypeParameterSymbol.get_Variance +Microsoft.CodeAnalysis.ITypeSymbol +Microsoft.CodeAnalysis.ITypeSymbol.FindImplementationForInterfaceMember(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.ITypeSymbol.ToDisplayParts(Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ITypeSymbol.ToDisplayString(Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ITypeSymbol.ToMinimalDisplayParts(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.NullableFlowState,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ITypeSymbol.ToMinimalDisplayString(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.NullableFlowState,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +Microsoft.CodeAnalysis.ITypeSymbol.WithNullableAnnotation(Microsoft.CodeAnalysis.NullableAnnotation) +Microsoft.CodeAnalysis.ITypeSymbol.get_AllInterfaces +Microsoft.CodeAnalysis.ITypeSymbol.get_BaseType +Microsoft.CodeAnalysis.ITypeSymbol.get_Interfaces +Microsoft.CodeAnalysis.ITypeSymbol.get_IsAnonymousType +Microsoft.CodeAnalysis.ITypeSymbol.get_IsNativeIntegerType +Microsoft.CodeAnalysis.ITypeSymbol.get_IsReadOnly +Microsoft.CodeAnalysis.ITypeSymbol.get_IsRecord +Microsoft.CodeAnalysis.ITypeSymbol.get_IsRefLikeType +Microsoft.CodeAnalysis.ITypeSymbol.get_IsReferenceType +Microsoft.CodeAnalysis.ITypeSymbol.get_IsTupleType +Microsoft.CodeAnalysis.ITypeSymbol.get_IsUnmanagedType +Microsoft.CodeAnalysis.ITypeSymbol.get_IsValueType +Microsoft.CodeAnalysis.ITypeSymbol.get_NullableAnnotation +Microsoft.CodeAnalysis.ITypeSymbol.get_OriginalDefinition +Microsoft.CodeAnalysis.ITypeSymbol.get_SpecialType +Microsoft.CodeAnalysis.ITypeSymbol.get_TypeKind +Microsoft.CodeAnalysis.ImportedNamespaceOrType +Microsoft.CodeAnalysis.ImportedNamespaceOrType.get_DeclaringSyntaxReference +Microsoft.CodeAnalysis.ImportedNamespaceOrType.get_NamespaceOrType +Microsoft.CodeAnalysis.ImportedXmlNamespace +Microsoft.CodeAnalysis.ImportedXmlNamespace.get_DeclaringSyntaxReference +Microsoft.CodeAnalysis.ImportedXmlNamespace.get_XmlNamespace +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterHostOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.HostOutputProductionContext,``0}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterHostOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.HostOutputProductionContext,``0}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterPostInitializationOutput(System.Action{Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_AdditionalTextsProvider +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_AnalyzerConfigOptionsProvider +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_CompilationProvider +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_MetadataReferencesProvider +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_ParseOptionsProvider +Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_SyntaxProvider +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Host +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Implementation +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.None +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.PostInit +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Source +Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.value__ +Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext +Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddEmbeddedAttributeDefinition +Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(System.String,System.String) +Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.get_CancellationToken +Microsoft.CodeAnalysis.IncrementalGeneratorRunStep +Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_ElapsedTime +Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Inputs +Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Name +Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Outputs +Microsoft.CodeAnalysis.IncrementalStepRunReason +Microsoft.CodeAnalysis.IncrementalStepRunReason.Cached +Microsoft.CodeAnalysis.IncrementalStepRunReason.Modified +Microsoft.CodeAnalysis.IncrementalStepRunReason.New +Microsoft.CodeAnalysis.IncrementalStepRunReason.Removed +Microsoft.CodeAnalysis.IncrementalStepRunReason.Unchanged +Microsoft.CodeAnalysis.IncrementalStepRunReason.value__ +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Collect``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},Microsoft.CodeAnalysis.IncrementalValueProvider{``1}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},Microsoft.CodeAnalysis.IncrementalValueProvider{``1}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Generic.IEnumerable{``1}}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Immutable.ImmutableArray{``1}}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Generic.IEnumerable{``1}}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Immutable.ImmutableArray{``1}}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,``1}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,``1}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Where``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Boolean}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Collections.Generic.IEqualityComparer{``0}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Collections.Generic.IEqualityComparer{``0}) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithTrackingName``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.String) +Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithTrackingName``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.String) +Microsoft.CodeAnalysis.IncrementalValueProvider`1 +Microsoft.CodeAnalysis.IncrementalValuesProvider`1 +Microsoft.CodeAnalysis.LanguageNames +Microsoft.CodeAnalysis.LanguageNames.CSharp +Microsoft.CodeAnalysis.LanguageNames.FSharp +Microsoft.CodeAnalysis.LanguageNames.VisualBasic +Microsoft.CodeAnalysis.LineMapping +Microsoft.CodeAnalysis.LineMapping.#ctor(Microsoft.CodeAnalysis.Text.LinePositionSpan,System.Nullable{System.Int32},Microsoft.CodeAnalysis.FileLinePositionSpan) +Microsoft.CodeAnalysis.LineMapping.Equals(Microsoft.CodeAnalysis.LineMapping) +Microsoft.CodeAnalysis.LineMapping.Equals(System.Object) +Microsoft.CodeAnalysis.LineMapping.GetHashCode +Microsoft.CodeAnalysis.LineMapping.ToString +Microsoft.CodeAnalysis.LineMapping.get_CharacterOffset +Microsoft.CodeAnalysis.LineMapping.get_IsHidden +Microsoft.CodeAnalysis.LineMapping.get_MappedSpan +Microsoft.CodeAnalysis.LineMapping.get_Span +Microsoft.CodeAnalysis.LineMapping.op_Equality(Microsoft.CodeAnalysis.LineMapping,Microsoft.CodeAnalysis.LineMapping) +Microsoft.CodeAnalysis.LineMapping.op_Inequality(Microsoft.CodeAnalysis.LineMapping,Microsoft.CodeAnalysis.LineMapping) +Microsoft.CodeAnalysis.LineVisibility +Microsoft.CodeAnalysis.LineVisibility.BeforeFirstLineDirective +Microsoft.CodeAnalysis.LineVisibility.Hidden +Microsoft.CodeAnalysis.LineVisibility.Visible +Microsoft.CodeAnalysis.LineVisibility.value__ +Microsoft.CodeAnalysis.LocalizableResourceString +Microsoft.CodeAnalysis.LocalizableResourceString.#ctor(System.String,System.Resources.ResourceManager,System.Type) +Microsoft.CodeAnalysis.LocalizableResourceString.#ctor(System.String,System.Resources.ResourceManager,System.Type,System.String[]) +Microsoft.CodeAnalysis.LocalizableResourceString.AreEqual(System.Object) +Microsoft.CodeAnalysis.LocalizableResourceString.GetHash +Microsoft.CodeAnalysis.LocalizableResourceString.GetText(System.IFormatProvider) +Microsoft.CodeAnalysis.LocalizableString +Microsoft.CodeAnalysis.LocalizableString.#ctor +Microsoft.CodeAnalysis.LocalizableString.AreEqual(System.Object) +Microsoft.CodeAnalysis.LocalizableString.Equals(Microsoft.CodeAnalysis.LocalizableString) +Microsoft.CodeAnalysis.LocalizableString.Equals(System.Object) +Microsoft.CodeAnalysis.LocalizableString.GetHash +Microsoft.CodeAnalysis.LocalizableString.GetHashCode +Microsoft.CodeAnalysis.LocalizableString.GetText(System.IFormatProvider) +Microsoft.CodeAnalysis.LocalizableString.ToString +Microsoft.CodeAnalysis.LocalizableString.ToString(System.IFormatProvider) +Microsoft.CodeAnalysis.LocalizableString.add_OnException(System.EventHandler{System.Exception}) +Microsoft.CodeAnalysis.LocalizableString.op_Explicit(Microsoft.CodeAnalysis.LocalizableString)~System.String +Microsoft.CodeAnalysis.LocalizableString.op_Implicit(System.String)~Microsoft.CodeAnalysis.LocalizableString +Microsoft.CodeAnalysis.LocalizableString.remove_OnException(System.EventHandler{System.Exception}) +Microsoft.CodeAnalysis.Location +Microsoft.CodeAnalysis.Location.Create(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Location.Create(System.String,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.Location.Create(System.String,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan,System.String,Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.Location.Equals(System.Object) +Microsoft.CodeAnalysis.Location.GetDebuggerDisplay +Microsoft.CodeAnalysis.Location.GetHashCode +Microsoft.CodeAnalysis.Location.GetLineSpan +Microsoft.CodeAnalysis.Location.GetMappedLineSpan +Microsoft.CodeAnalysis.Location.ToString +Microsoft.CodeAnalysis.Location.get_IsInMetadata +Microsoft.CodeAnalysis.Location.get_IsInSource +Microsoft.CodeAnalysis.Location.get_Kind +Microsoft.CodeAnalysis.Location.get_MetadataModule +Microsoft.CodeAnalysis.Location.get_None +Microsoft.CodeAnalysis.Location.get_SourceSpan +Microsoft.CodeAnalysis.Location.get_SourceTree +Microsoft.CodeAnalysis.Location.op_Equality(Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.Location) +Microsoft.CodeAnalysis.Location.op_Inequality(Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.Location) +Microsoft.CodeAnalysis.LocationKind +Microsoft.CodeAnalysis.LocationKind.ExternalFile +Microsoft.CodeAnalysis.LocationKind.MetadataFile +Microsoft.CodeAnalysis.LocationKind.None +Microsoft.CodeAnalysis.LocationKind.SourceFile +Microsoft.CodeAnalysis.LocationKind.XmlFile +Microsoft.CodeAnalysis.LocationKind.value__ +Microsoft.CodeAnalysis.Metadata +Microsoft.CodeAnalysis.Metadata.CommonCopy +Microsoft.CodeAnalysis.Metadata.Copy +Microsoft.CodeAnalysis.Metadata.Dispose +Microsoft.CodeAnalysis.Metadata.get_Id +Microsoft.CodeAnalysis.Metadata.get_Kind +Microsoft.CodeAnalysis.MetadataId +Microsoft.CodeAnalysis.MetadataImageKind +Microsoft.CodeAnalysis.MetadataImageKind.Assembly +Microsoft.CodeAnalysis.MetadataImageKind.Module +Microsoft.CodeAnalysis.MetadataImageKind.value__ +Microsoft.CodeAnalysis.MetadataImportOptions +Microsoft.CodeAnalysis.MetadataImportOptions.All +Microsoft.CodeAnalysis.MetadataImportOptions.Internal +Microsoft.CodeAnalysis.MetadataImportOptions.Public +Microsoft.CodeAnalysis.MetadataImportOptions.value__ +Microsoft.CodeAnalysis.MetadataReference +Microsoft.CodeAnalysis.MetadataReference.#ctor(Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.MetadataReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.MetadataReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.MetadataReference.WithEmbedInteropTypes(System.Boolean) +Microsoft.CodeAnalysis.MetadataReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.MetadataReference.get_Display +Microsoft.CodeAnalysis.MetadataReference.get_Properties +Microsoft.CodeAnalysis.MetadataReferenceProperties +Microsoft.CodeAnalysis.MetadataReferenceProperties.#ctor(Microsoft.CodeAnalysis.MetadataImageKind,System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) +Microsoft.CodeAnalysis.MetadataReferenceProperties.Equals(Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.MetadataReferenceProperties.Equals(System.Object) +Microsoft.CodeAnalysis.MetadataReferenceProperties.GetHashCode +Microsoft.CodeAnalysis.MetadataReferenceProperties.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.MetadataReferenceProperties.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.MetadataReferenceProperties.WithEmbedInteropTypes(System.Boolean) +Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Aliases +Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Assembly +Microsoft.CodeAnalysis.MetadataReferenceProperties.get_EmbedInteropTypes +Microsoft.CodeAnalysis.MetadataReferenceProperties.get_GlobalAlias +Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Kind +Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Module +Microsoft.CodeAnalysis.MetadataReferenceProperties.op_Equality(Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.MetadataReferenceProperties.op_Inequality(Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.MetadataReferenceResolver +Microsoft.CodeAnalysis.MethodKind +Microsoft.CodeAnalysis.MethodKind.AnonymousFunction +Microsoft.CodeAnalysis.MethodKind.BuiltinOperator +Microsoft.CodeAnalysis.MethodKind.Constructor +Microsoft.CodeAnalysis.MethodKind.Conversion +Microsoft.CodeAnalysis.MethodKind.DeclareMethod +Microsoft.CodeAnalysis.MethodKind.DelegateInvoke +Microsoft.CodeAnalysis.MethodKind.Destructor +Microsoft.CodeAnalysis.MethodKind.EventAdd +Microsoft.CodeAnalysis.MethodKind.EventRaise +Microsoft.CodeAnalysis.MethodKind.EventRemove +Microsoft.CodeAnalysis.MethodKind.ExplicitInterfaceImplementation +Microsoft.CodeAnalysis.MethodKind.FunctionPointerSignature +Microsoft.CodeAnalysis.MethodKind.LambdaMethod +Microsoft.CodeAnalysis.MethodKind.LocalFunction +Microsoft.CodeAnalysis.MethodKind.Ordinary +Microsoft.CodeAnalysis.MethodKind.PropertyGet +Microsoft.CodeAnalysis.MethodKind.PropertySet +Microsoft.CodeAnalysis.MethodKind.ReducedExtension +Microsoft.CodeAnalysis.MethodKind.SharedConstructor +Microsoft.CodeAnalysis.MethodKind.StaticConstructor +Microsoft.CodeAnalysis.MethodKind.UserDefinedOperator +Microsoft.CodeAnalysis.MethodKind.value__ +Microsoft.CodeAnalysis.ModelExtensions +Microsoft.CodeAnalysis.ModelExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.ModelExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.ModelExtensions.GetAliasInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.ModelExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.ModelExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeAliasInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeTypeInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.ModelExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.ModelExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.ModuleMetadata +Microsoft.CodeAnalysis.ModuleMetadata.CommonCopy +Microsoft.CodeAnalysis.ModuleMetadata.Dispose +Microsoft.CodeAnalysis.ModuleMetadata.GetMetadataReader +Microsoft.CodeAnalysis.ModuleMetadata.GetModuleNames +Microsoft.CodeAnalysis.ModuleMetadata.GetModuleVersionId +Microsoft.CodeAnalysis.ModuleMetadata.GetReference(Microsoft.CodeAnalysis.DocumentationProvider,System.String,System.String) +Microsoft.CodeAnalysis.ModuleMetadata.get_IsDisposed +Microsoft.CodeAnalysis.ModuleMetadata.get_Kind +Microsoft.CodeAnalysis.ModuleMetadata.get_Name +Microsoft.CodeAnalysis.NamespaceKind +Microsoft.CodeAnalysis.NamespaceKind.Assembly +Microsoft.CodeAnalysis.NamespaceKind.Compilation +Microsoft.CodeAnalysis.NamespaceKind.Module +Microsoft.CodeAnalysis.NamespaceKind.value__ +Microsoft.CodeAnalysis.NullabilityInfo +Microsoft.CodeAnalysis.NullabilityInfo.Equals(Microsoft.CodeAnalysis.NullabilityInfo) +Microsoft.CodeAnalysis.NullabilityInfo.Equals(System.Object) +Microsoft.CodeAnalysis.NullabilityInfo.GetHashCode +Microsoft.CodeAnalysis.NullabilityInfo.get_Annotation +Microsoft.CodeAnalysis.NullabilityInfo.get_FlowState +Microsoft.CodeAnalysis.NullableAnnotation +Microsoft.CodeAnalysis.NullableAnnotation.Annotated +Microsoft.CodeAnalysis.NullableAnnotation.None +Microsoft.CodeAnalysis.NullableAnnotation.NotAnnotated +Microsoft.CodeAnalysis.NullableAnnotation.value__ +Microsoft.CodeAnalysis.NullableContext +Microsoft.CodeAnalysis.NullableContext.AnnotationsContextInherited +Microsoft.CodeAnalysis.NullableContext.AnnotationsEnabled +Microsoft.CodeAnalysis.NullableContext.ContextInherited +Microsoft.CodeAnalysis.NullableContext.Disabled +Microsoft.CodeAnalysis.NullableContext.Enabled +Microsoft.CodeAnalysis.NullableContext.WarningsContextInherited +Microsoft.CodeAnalysis.NullableContext.WarningsEnabled +Microsoft.CodeAnalysis.NullableContext.value__ +Microsoft.CodeAnalysis.NullableContextExtensions +Microsoft.CodeAnalysis.NullableContextExtensions.AnnotationsEnabled(Microsoft.CodeAnalysis.NullableContext) +Microsoft.CodeAnalysis.NullableContextExtensions.AnnotationsInherited(Microsoft.CodeAnalysis.NullableContext) +Microsoft.CodeAnalysis.NullableContextExtensions.WarningsEnabled(Microsoft.CodeAnalysis.NullableContext) +Microsoft.CodeAnalysis.NullableContextExtensions.WarningsInherited(Microsoft.CodeAnalysis.NullableContext) +Microsoft.CodeAnalysis.NullableContextOptions +Microsoft.CodeAnalysis.NullableContextOptions.Annotations +Microsoft.CodeAnalysis.NullableContextOptions.Disable +Microsoft.CodeAnalysis.NullableContextOptions.Enable +Microsoft.CodeAnalysis.NullableContextOptions.Warnings +Microsoft.CodeAnalysis.NullableContextOptions.value__ +Microsoft.CodeAnalysis.NullableContextOptionsExtensions +Microsoft.CodeAnalysis.NullableContextOptionsExtensions.AnnotationsEnabled(Microsoft.CodeAnalysis.NullableContextOptions) +Microsoft.CodeAnalysis.NullableContextOptionsExtensions.WarningsEnabled(Microsoft.CodeAnalysis.NullableContextOptions) +Microsoft.CodeAnalysis.NullableFlowState +Microsoft.CodeAnalysis.NullableFlowState.MaybeNull +Microsoft.CodeAnalysis.NullableFlowState.None +Microsoft.CodeAnalysis.NullableFlowState.NotNull +Microsoft.CodeAnalysis.NullableFlowState.value__ +Microsoft.CodeAnalysis.OperationKind +Microsoft.CodeAnalysis.OperationKind.AddressOf +Microsoft.CodeAnalysis.OperationKind.AnonymousFunction +Microsoft.CodeAnalysis.OperationKind.AnonymousObjectCreation +Microsoft.CodeAnalysis.OperationKind.Argument +Microsoft.CodeAnalysis.OperationKind.ArrayCreation +Microsoft.CodeAnalysis.OperationKind.ArrayElementReference +Microsoft.CodeAnalysis.OperationKind.ArrayInitializer +Microsoft.CodeAnalysis.OperationKind.Attribute +Microsoft.CodeAnalysis.OperationKind.Await +Microsoft.CodeAnalysis.OperationKind.Binary +Microsoft.CodeAnalysis.OperationKind.BinaryOperator +Microsoft.CodeAnalysis.OperationKind.BinaryPattern +Microsoft.CodeAnalysis.OperationKind.Block +Microsoft.CodeAnalysis.OperationKind.Branch +Microsoft.CodeAnalysis.OperationKind.CaseClause +Microsoft.CodeAnalysis.OperationKind.CatchClause +Microsoft.CodeAnalysis.OperationKind.CaughtException +Microsoft.CodeAnalysis.OperationKind.Coalesce +Microsoft.CodeAnalysis.OperationKind.CoalesceAssignment +Microsoft.CodeAnalysis.OperationKind.CollectionElementInitializer +Microsoft.CodeAnalysis.OperationKind.CollectionExpression +Microsoft.CodeAnalysis.OperationKind.CompoundAssignment +Microsoft.CodeAnalysis.OperationKind.Conditional +Microsoft.CodeAnalysis.OperationKind.ConditionalAccess +Microsoft.CodeAnalysis.OperationKind.ConditionalAccessInstance +Microsoft.CodeAnalysis.OperationKind.ConstantPattern +Microsoft.CodeAnalysis.OperationKind.ConstructorBody +Microsoft.CodeAnalysis.OperationKind.ConstructorBodyOperation +Microsoft.CodeAnalysis.OperationKind.Conversion +Microsoft.CodeAnalysis.OperationKind.DeclarationExpression +Microsoft.CodeAnalysis.OperationKind.DeclarationPattern +Microsoft.CodeAnalysis.OperationKind.DeconstructionAssignment +Microsoft.CodeAnalysis.OperationKind.Decrement +Microsoft.CodeAnalysis.OperationKind.DefaultValue +Microsoft.CodeAnalysis.OperationKind.DelegateCreation +Microsoft.CodeAnalysis.OperationKind.Discard +Microsoft.CodeAnalysis.OperationKind.DiscardPattern +Microsoft.CodeAnalysis.OperationKind.DynamicIndexerAccess +Microsoft.CodeAnalysis.OperationKind.DynamicInvocation +Microsoft.CodeAnalysis.OperationKind.DynamicMemberReference +Microsoft.CodeAnalysis.OperationKind.DynamicObjectCreation +Microsoft.CodeAnalysis.OperationKind.Empty +Microsoft.CodeAnalysis.OperationKind.End +Microsoft.CodeAnalysis.OperationKind.EventAssignment +Microsoft.CodeAnalysis.OperationKind.EventReference +Microsoft.CodeAnalysis.OperationKind.ExpressionStatement +Microsoft.CodeAnalysis.OperationKind.FieldInitializer +Microsoft.CodeAnalysis.OperationKind.FieldReference +Microsoft.CodeAnalysis.OperationKind.FlowAnonymousFunction +Microsoft.CodeAnalysis.OperationKind.FlowCapture +Microsoft.CodeAnalysis.OperationKind.FlowCaptureReference +Microsoft.CodeAnalysis.OperationKind.FunctionPointerInvocation +Microsoft.CodeAnalysis.OperationKind.ImplicitIndexerReference +Microsoft.CodeAnalysis.OperationKind.Increment +Microsoft.CodeAnalysis.OperationKind.InlineArrayAccess +Microsoft.CodeAnalysis.OperationKind.InstanceReference +Microsoft.CodeAnalysis.OperationKind.InterpolatedString +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAddition +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendFormatted +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendInvalid +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendLiteral +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringHandlerArgumentPlaceholder +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringHandlerCreation +Microsoft.CodeAnalysis.OperationKind.InterpolatedStringText +Microsoft.CodeAnalysis.OperationKind.Interpolation +Microsoft.CodeAnalysis.OperationKind.Invalid +Microsoft.CodeAnalysis.OperationKind.Invocation +Microsoft.CodeAnalysis.OperationKind.IsNull +Microsoft.CodeAnalysis.OperationKind.IsPattern +Microsoft.CodeAnalysis.OperationKind.IsType +Microsoft.CodeAnalysis.OperationKind.Labeled +Microsoft.CodeAnalysis.OperationKind.ListPattern +Microsoft.CodeAnalysis.OperationKind.Literal +Microsoft.CodeAnalysis.OperationKind.LocalFunction +Microsoft.CodeAnalysis.OperationKind.LocalReference +Microsoft.CodeAnalysis.OperationKind.Lock +Microsoft.CodeAnalysis.OperationKind.Loop +Microsoft.CodeAnalysis.OperationKind.MemberInitializer +Microsoft.CodeAnalysis.OperationKind.MethodBody +Microsoft.CodeAnalysis.OperationKind.MethodBodyOperation +Microsoft.CodeAnalysis.OperationKind.MethodReference +Microsoft.CodeAnalysis.OperationKind.NameOf +Microsoft.CodeAnalysis.OperationKind.NegatedPattern +Microsoft.CodeAnalysis.OperationKind.None +Microsoft.CodeAnalysis.OperationKind.ObjectCreation +Microsoft.CodeAnalysis.OperationKind.ObjectOrCollectionInitializer +Microsoft.CodeAnalysis.OperationKind.OmittedArgument +Microsoft.CodeAnalysis.OperationKind.ParameterInitializer +Microsoft.CodeAnalysis.OperationKind.ParameterReference +Microsoft.CodeAnalysis.OperationKind.Parenthesized +Microsoft.CodeAnalysis.OperationKind.PropertyInitializer +Microsoft.CodeAnalysis.OperationKind.PropertyReference +Microsoft.CodeAnalysis.OperationKind.PropertySubpattern +Microsoft.CodeAnalysis.OperationKind.RaiseEvent +Microsoft.CodeAnalysis.OperationKind.Range +Microsoft.CodeAnalysis.OperationKind.ReDim +Microsoft.CodeAnalysis.OperationKind.ReDimClause +Microsoft.CodeAnalysis.OperationKind.RecursivePattern +Microsoft.CodeAnalysis.OperationKind.RelationalPattern +Microsoft.CodeAnalysis.OperationKind.Return +Microsoft.CodeAnalysis.OperationKind.SimpleAssignment +Microsoft.CodeAnalysis.OperationKind.SizeOf +Microsoft.CodeAnalysis.OperationKind.SlicePattern +Microsoft.CodeAnalysis.OperationKind.Spread +Microsoft.CodeAnalysis.OperationKind.StaticLocalInitializationSemaphore +Microsoft.CodeAnalysis.OperationKind.Stop +Microsoft.CodeAnalysis.OperationKind.Switch +Microsoft.CodeAnalysis.OperationKind.SwitchCase +Microsoft.CodeAnalysis.OperationKind.SwitchExpression +Microsoft.CodeAnalysis.OperationKind.SwitchExpressionArm +Microsoft.CodeAnalysis.OperationKind.Throw +Microsoft.CodeAnalysis.OperationKind.TranslatedQuery +Microsoft.CodeAnalysis.OperationKind.Try +Microsoft.CodeAnalysis.OperationKind.Tuple +Microsoft.CodeAnalysis.OperationKind.TupleBinary +Microsoft.CodeAnalysis.OperationKind.TupleBinaryOperator +Microsoft.CodeAnalysis.OperationKind.TypeOf +Microsoft.CodeAnalysis.OperationKind.TypeParameterObjectCreation +Microsoft.CodeAnalysis.OperationKind.TypePattern +Microsoft.CodeAnalysis.OperationKind.Unary +Microsoft.CodeAnalysis.OperationKind.UnaryOperator +Microsoft.CodeAnalysis.OperationKind.Using +Microsoft.CodeAnalysis.OperationKind.UsingDeclaration +Microsoft.CodeAnalysis.OperationKind.Utf8String +Microsoft.CodeAnalysis.OperationKind.VariableDeclaration +Microsoft.CodeAnalysis.OperationKind.VariableDeclarationGroup +Microsoft.CodeAnalysis.OperationKind.VariableDeclarator +Microsoft.CodeAnalysis.OperationKind.VariableInitializer +Microsoft.CodeAnalysis.OperationKind.With +Microsoft.CodeAnalysis.OperationKind.YieldBreak +Microsoft.CodeAnalysis.OperationKind.YieldReturn +Microsoft.CodeAnalysis.OperationKind.value__ +Microsoft.CodeAnalysis.Operations.ArgumentKind +Microsoft.CodeAnalysis.Operations.ArgumentKind.DefaultValue +Microsoft.CodeAnalysis.Operations.ArgumentKind.Explicit +Microsoft.CodeAnalysis.Operations.ArgumentKind.None +Microsoft.CodeAnalysis.Operations.ArgumentKind.ParamArray +Microsoft.CodeAnalysis.Operations.ArgumentKind.ParamCollection +Microsoft.CodeAnalysis.Operations.ArgumentKind.value__ +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Add +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.And +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Concatenate +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ConditionalAnd +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ConditionalOr +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Divide +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Equals +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ExclusiveOr +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.GreaterThan +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.GreaterThanOrEqual +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.IntegerDivide +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LeftShift +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LessThan +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LessThanOrEqual +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Like +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Multiply +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.None +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.NotEquals +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ObjectValueEquals +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ObjectValueNotEquals +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Or +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Power +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Remainder +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.RightShift +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Subtract +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.UnsignedRightShift +Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.value__ +Microsoft.CodeAnalysis.Operations.BranchKind +Microsoft.CodeAnalysis.Operations.BranchKind.Break +Microsoft.CodeAnalysis.Operations.BranchKind.Continue +Microsoft.CodeAnalysis.Operations.BranchKind.GoTo +Microsoft.CodeAnalysis.Operations.BranchKind.None +Microsoft.CodeAnalysis.Operations.BranchKind.value__ +Microsoft.CodeAnalysis.Operations.CaseKind +Microsoft.CodeAnalysis.Operations.CaseKind.Default +Microsoft.CodeAnalysis.Operations.CaseKind.None +Microsoft.CodeAnalysis.Operations.CaseKind.Pattern +Microsoft.CodeAnalysis.Operations.CaseKind.Range +Microsoft.CodeAnalysis.Operations.CaseKind.Relational +Microsoft.CodeAnalysis.Operations.CaseKind.SingleValue +Microsoft.CodeAnalysis.Operations.CaseKind.value__ +Microsoft.CodeAnalysis.Operations.CommonConversion +Microsoft.CodeAnalysis.Operations.CommonConversion.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.CommonConversion.get_Exists +Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsIdentity +Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsImplicit +Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsNullable +Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsNumeric +Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsReference +Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsUserDefined +Microsoft.CodeAnalysis.Operations.CommonConversion.get_MethodSymbol +Microsoft.CodeAnalysis.Operations.IAddressOfOperation +Microsoft.CodeAnalysis.Operations.IAddressOfOperation.get_Reference +Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation +Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation.get_Body +Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation.get_Symbol +Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation +Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation.get_Initializers +Microsoft.CodeAnalysis.Operations.IArgumentOperation +Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_ArgumentKind +Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_InConversion +Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_OutConversion +Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_Parameter +Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_Value +Microsoft.CodeAnalysis.Operations.IArrayCreationOperation +Microsoft.CodeAnalysis.Operations.IArrayCreationOperation.get_DimensionSizes +Microsoft.CodeAnalysis.Operations.IArrayCreationOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation +Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation.get_ArrayReference +Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation.get_Indices +Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation +Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation.get_ElementValues +Microsoft.CodeAnalysis.Operations.IAssignmentOperation +Microsoft.CodeAnalysis.Operations.IAssignmentOperation.get_Target +Microsoft.CodeAnalysis.Operations.IAssignmentOperation.get_Value +Microsoft.CodeAnalysis.Operations.IAttributeOperation +Microsoft.CodeAnalysis.Operations.IAttributeOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IAwaitOperation +Microsoft.CodeAnalysis.Operations.IAwaitOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IBinaryOperation +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsChecked +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsCompareText +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsLifted +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_LeftOperand +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_OperatorKind +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_OperatorMethod +Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_RightOperand +Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation +Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_LeftPattern +Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_OperatorKind +Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_RightPattern +Microsoft.CodeAnalysis.Operations.IBlockOperation +Microsoft.CodeAnalysis.Operations.IBlockOperation.get_Locals +Microsoft.CodeAnalysis.Operations.IBlockOperation.get_Operations +Microsoft.CodeAnalysis.Operations.IBranchOperation +Microsoft.CodeAnalysis.Operations.IBranchOperation.get_BranchKind +Microsoft.CodeAnalysis.Operations.IBranchOperation.get_Target +Microsoft.CodeAnalysis.Operations.ICaseClauseOperation +Microsoft.CodeAnalysis.Operations.ICaseClauseOperation.get_CaseKind +Microsoft.CodeAnalysis.Operations.ICaseClauseOperation.get_Label +Microsoft.CodeAnalysis.Operations.ICatchClauseOperation +Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_ExceptionDeclarationOrExpression +Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_ExceptionType +Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Filter +Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Handler +Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Locals +Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation +Microsoft.CodeAnalysis.Operations.ICoalesceOperation +Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_Value +Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_ValueConversion +Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_WhenNull +Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation +Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_AddMethod +Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_IsDynamic +Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation +Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation.get_ConstructMethod +Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation.get_Elements +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_InConversion +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_IsChecked +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_IsLifted +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OperatorKind +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OperatorMethod +Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OutConversion +Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation +Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation +Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation.get_WhenNotNull +Microsoft.CodeAnalysis.Operations.IConditionalOperation +Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_Condition +Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_IsRef +Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_WhenFalse +Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_WhenTrue +Microsoft.CodeAnalysis.Operations.IConstantPatternOperation +Microsoft.CodeAnalysis.Operations.IConstantPatternOperation.get_Value +Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation +Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation.get_Locals +Microsoft.CodeAnalysis.Operations.IConversionOperation +Microsoft.CodeAnalysis.Operations.IConversionOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.IConversionOperation.get_Conversion +Microsoft.CodeAnalysis.Operations.IConversionOperation.get_IsChecked +Microsoft.CodeAnalysis.Operations.IConversionOperation.get_IsTryCast +Microsoft.CodeAnalysis.Operations.IConversionOperation.get_Operand +Microsoft.CodeAnalysis.Operations.IConversionOperation.get_OperatorMethod +Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation +Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation.get_Expression +Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation +Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_DeclaredSymbol +Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_MatchedType +Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_MatchesNull +Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation +Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation +Microsoft.CodeAnalysis.Operations.IDefaultValueOperation +Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation +Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation.get_Target +Microsoft.CodeAnalysis.Operations.IDiscardOperation +Microsoft.CodeAnalysis.Operations.IDiscardOperation.get_DiscardSymbol +Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation +Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation +Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation +Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation +Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_ContainingType +Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_Instance +Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_MemberName +Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_TypeArguments +Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation +Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IEmptyOperation +Microsoft.CodeAnalysis.Operations.IEndOperation +Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation +Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_Adds +Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_EventReference +Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_HandlerValue +Microsoft.CodeAnalysis.Operations.IEventReferenceOperation +Microsoft.CodeAnalysis.Operations.IEventReferenceOperation.get_Event +Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation +Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation +Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation.get_InitializedFields +Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation +Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation.get_Field +Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation.get_IsDeclaration +Microsoft.CodeAnalysis.Operations.IForEachLoopOperation +Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_Collection +Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_IsAsynchronous +Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_LoopControlVariable +Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_NextVariables +Microsoft.CodeAnalysis.Operations.IForLoopOperation +Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_AtLoopBottom +Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_Before +Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_Condition +Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_ConditionLocals +Microsoft.CodeAnalysis.Operations.IForToLoopOperation +Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_InitialValue +Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_IsChecked +Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_LimitValue +Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_LoopControlVariable +Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_NextVariables +Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_StepValue +Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation +Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation.get_Target +Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation +Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_Argument +Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_IndexerSymbol +Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_Instance +Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_LengthSymbol +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsChecked +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsLifted +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsPostfix +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_OperatorMethod +Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_Target +Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation +Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation.get_Argument +Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation.get_Instance +Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation +Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation.get_ReferenceKind +Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation.get_Left +Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation.get_Right +Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation.get_AppendCall +Microsoft.CodeAnalysis.Operations.IInterpolatedStringContentOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation.get_ArgumentIndex +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation.get_PlaceholderKind +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_Content +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerAppendCallsReturnBool +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerCreation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerCreationHasSuccessParameter +Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation.get_Parts +Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation +Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation.get_Text +Microsoft.CodeAnalysis.Operations.IInterpolationOperation +Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_Alignment +Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_Expression +Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_FormatString +Microsoft.CodeAnalysis.Operations.IInvalidOperation +Microsoft.CodeAnalysis.Operations.IInvocationOperation +Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_Instance +Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_IsVirtual +Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_TargetMethod +Microsoft.CodeAnalysis.Operations.IIsPatternOperation +Microsoft.CodeAnalysis.Operations.IIsPatternOperation.get_Pattern +Microsoft.CodeAnalysis.Operations.IIsPatternOperation.get_Value +Microsoft.CodeAnalysis.Operations.IIsTypeOperation +Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_IsNegated +Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_TypeOperand +Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_ValueOperand +Microsoft.CodeAnalysis.Operations.ILabeledOperation +Microsoft.CodeAnalysis.Operations.ILabeledOperation.get_Label +Microsoft.CodeAnalysis.Operations.ILabeledOperation.get_Operation +Microsoft.CodeAnalysis.Operations.IListPatternOperation +Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_DeclaredSymbol +Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_IndexerSymbol +Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_LengthSymbol +Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_Patterns +Microsoft.CodeAnalysis.Operations.ILiteralOperation +Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation +Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_Body +Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_IgnoredBody +Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_Symbol +Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation +Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation.get_IsDeclaration +Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation.get_Local +Microsoft.CodeAnalysis.Operations.ILockOperation +Microsoft.CodeAnalysis.Operations.ILockOperation.get_Body +Microsoft.CodeAnalysis.Operations.ILockOperation.get_LockedValue +Microsoft.CodeAnalysis.Operations.ILoopOperation +Microsoft.CodeAnalysis.Operations.ILoopOperation.get_Body +Microsoft.CodeAnalysis.Operations.ILoopOperation.get_ContinueLabel +Microsoft.CodeAnalysis.Operations.ILoopOperation.get_ExitLabel +Microsoft.CodeAnalysis.Operations.ILoopOperation.get_Locals +Microsoft.CodeAnalysis.Operations.ILoopOperation.get_LoopKind +Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation +Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation.get_InitializedMember +Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation +Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_Instance +Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_Member +Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation +Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation.get_BlockBody +Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation.get_ExpressionBody +Microsoft.CodeAnalysis.Operations.IMethodBodyOperation +Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation +Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation.get_IsVirtual +Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation.get_Method +Microsoft.CodeAnalysis.Operations.INameOfOperation +Microsoft.CodeAnalysis.Operations.INameOfOperation.get_Argument +Microsoft.CodeAnalysis.Operations.INegatedPatternOperation +Microsoft.CodeAnalysis.Operations.INegatedPatternOperation.get_Pattern +Microsoft.CodeAnalysis.Operations.IObjectCreationOperation +Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Constructor +Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation +Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation.get_Initializers +Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation +Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation +Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation.get_Parameter +Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation +Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation.get_Parameter +Microsoft.CodeAnalysis.Operations.IParenthesizedOperation +Microsoft.CodeAnalysis.Operations.IParenthesizedOperation.get_Operand +Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation +Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Guard +Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Label +Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Pattern +Microsoft.CodeAnalysis.Operations.IPatternOperation +Microsoft.CodeAnalysis.Operations.IPatternOperation.get_InputType +Microsoft.CodeAnalysis.Operations.IPatternOperation.get_NarrowedType +Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation +Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation.get_InitializedProperties +Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation +Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation.get_Property +Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation +Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation.get_Member +Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation.get_Pattern +Microsoft.CodeAnalysis.Operations.IRaiseEventOperation +Microsoft.CodeAnalysis.Operations.IRaiseEventOperation.get_Arguments +Microsoft.CodeAnalysis.Operations.IRaiseEventOperation.get_EventReference +Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation +Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation.get_MaximumValue +Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation.get_MinimumValue +Microsoft.CodeAnalysis.Operations.IRangeOperation +Microsoft.CodeAnalysis.Operations.IRangeOperation.get_IsLifted +Microsoft.CodeAnalysis.Operations.IRangeOperation.get_LeftOperand +Microsoft.CodeAnalysis.Operations.IRangeOperation.get_Method +Microsoft.CodeAnalysis.Operations.IRangeOperation.get_RightOperand +Microsoft.CodeAnalysis.Operations.IReDimClauseOperation +Microsoft.CodeAnalysis.Operations.IReDimClauseOperation.get_DimensionSizes +Microsoft.CodeAnalysis.Operations.IReDimClauseOperation.get_Operand +Microsoft.CodeAnalysis.Operations.IReDimOperation +Microsoft.CodeAnalysis.Operations.IReDimOperation.get_Clauses +Microsoft.CodeAnalysis.Operations.IReDimOperation.get_Preserve +Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation +Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeclaredSymbol +Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeconstructSymbol +Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeconstructionSubpatterns +Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_MatchedType +Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_PropertySubpatterns +Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation +Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation.get_Relation +Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation.get_Value +Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation +Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation.get_OperatorKind +Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation.get_Value +Microsoft.CodeAnalysis.Operations.IReturnOperation +Microsoft.CodeAnalysis.Operations.IReturnOperation.get_ReturnedValue +Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation +Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation.get_IsRef +Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation +Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation.get_Value +Microsoft.CodeAnalysis.Operations.ISizeOfOperation +Microsoft.CodeAnalysis.Operations.ISizeOfOperation.get_TypeOperand +Microsoft.CodeAnalysis.Operations.ISlicePatternOperation +Microsoft.CodeAnalysis.Operations.ISlicePatternOperation.get_Pattern +Microsoft.CodeAnalysis.Operations.ISlicePatternOperation.get_SliceSymbol +Microsoft.CodeAnalysis.Operations.ISpreadOperation +Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_ElementConversion +Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_ElementType +Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_Operand +Microsoft.CodeAnalysis.Operations.IStopOperation +Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation +Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Body +Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Clauses +Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Locals +Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation +Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Guard +Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Locals +Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Pattern +Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Value +Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation +Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_Arms +Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_IsExhaustive +Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_Value +Microsoft.CodeAnalysis.Operations.ISwitchOperation +Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Cases +Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_ExitLabel +Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Locals +Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Value +Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation +Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation.get_Locals +Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation.get_Value +Microsoft.CodeAnalysis.Operations.IThrowOperation +Microsoft.CodeAnalysis.Operations.IThrowOperation.get_Exception +Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation +Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation.get_Operation +Microsoft.CodeAnalysis.Operations.ITryOperation +Microsoft.CodeAnalysis.Operations.ITryOperation.get_Body +Microsoft.CodeAnalysis.Operations.ITryOperation.get_Catches +Microsoft.CodeAnalysis.Operations.ITryOperation.get_ExitLabel +Microsoft.CodeAnalysis.Operations.ITryOperation.get_Finally +Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation +Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_LeftOperand +Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_OperatorKind +Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_RightOperand +Microsoft.CodeAnalysis.Operations.ITupleOperation +Microsoft.CodeAnalysis.Operations.ITupleOperation.get_Elements +Microsoft.CodeAnalysis.Operations.ITupleOperation.get_NaturalType +Microsoft.CodeAnalysis.Operations.ITypeOfOperation +Microsoft.CodeAnalysis.Operations.ITypeOfOperation.get_TypeOperand +Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation +Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.ITypePatternOperation +Microsoft.CodeAnalysis.Operations.ITypePatternOperation.get_MatchedType +Microsoft.CodeAnalysis.Operations.IUnaryOperation +Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_ConstrainedToType +Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_IsChecked +Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_IsLifted +Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_Operand +Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_OperatorKind +Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_OperatorMethod +Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation +Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation.get_DeclarationGroup +Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation.get_IsAsynchronous +Microsoft.CodeAnalysis.Operations.IUsingOperation +Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Body +Microsoft.CodeAnalysis.Operations.IUsingOperation.get_IsAsynchronous +Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Locals +Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Resources +Microsoft.CodeAnalysis.Operations.IUtf8StringOperation +Microsoft.CodeAnalysis.Operations.IUtf8StringOperation.get_Value +Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation +Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation.get_Declarations +Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation +Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_Declarators +Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_IgnoredDimensions +Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation +Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_IgnoredArguments +Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_Symbol +Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation +Microsoft.CodeAnalysis.Operations.IWhileLoopOperation +Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_Condition +Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_ConditionIsTop +Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_ConditionIsUntil +Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_IgnoredCondition +Microsoft.CodeAnalysis.Operations.IWithOperation +Microsoft.CodeAnalysis.Operations.IWithOperation.get_CloneMethod +Microsoft.CodeAnalysis.Operations.IWithOperation.get_Initializer +Microsoft.CodeAnalysis.Operations.IWithOperation.get_Operand +Microsoft.CodeAnalysis.Operations.InstanceReferenceKind +Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.ContainingTypeInstance +Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.ImplicitReceiver +Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.InterpolatedStringHandler +Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.PatternInput +Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.value__ +Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind +Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.CallsiteArgument +Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.CallsiteReceiver +Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.TrailingValidityArgument +Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.value__ +Microsoft.CodeAnalysis.Operations.LoopKind +Microsoft.CodeAnalysis.Operations.LoopKind.For +Microsoft.CodeAnalysis.Operations.LoopKind.ForEach +Microsoft.CodeAnalysis.Operations.LoopKind.ForTo +Microsoft.CodeAnalysis.Operations.LoopKind.None +Microsoft.CodeAnalysis.Operations.LoopKind.While +Microsoft.CodeAnalysis.Operations.LoopKind.value__ +Microsoft.CodeAnalysis.Operations.OperationExtensions +Microsoft.CodeAnalysis.Operations.OperationExtensions.Descendants(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Operations.OperationExtensions.DescendantsAndSelf(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,System.Int32) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,System.Int32) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,System.Int32) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,System.Int32) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,System.Int32) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,System.Int32) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetCorrespondingOperation(Microsoft.CodeAnalysis.Operations.IBranchOperation) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetDeclaredVariables(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetDeclaredVariables(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetFunctionPointerSignature(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation) +Microsoft.CodeAnalysis.Operations.OperationExtensions.GetVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor +Microsoft.CodeAnalysis.Operations.OperationVisitor.#ctor +Microsoft.CodeAnalysis.Operations.OperationVisitor.DefaultVisit(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.Visit(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAddressOf(Microsoft.CodeAnalysis.Operations.IAddressOfOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAnonymousFunction(Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAnonymousObjectCreation(Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArgument(Microsoft.CodeAnalysis.Operations.IArgumentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayCreation(Microsoft.CodeAnalysis.Operations.IArrayCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayElementReference(Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayInitializer(Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAttribute(Microsoft.CodeAnalysis.Operations.IAttributeOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAwait(Microsoft.CodeAnalysis.Operations.IAwaitOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBinaryOperator(Microsoft.CodeAnalysis.Operations.IBinaryOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBlock(Microsoft.CodeAnalysis.Operations.IBlockOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBranch(Microsoft.CodeAnalysis.Operations.IBranchOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCatchClause(Microsoft.CodeAnalysis.Operations.ICatchClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCaughtException(Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCoalesce(Microsoft.CodeAnalysis.Operations.ICoalesceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCoalesceAssignment(Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCollectionElementInitializer(Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCollectionExpression(Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCompoundAssignment(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditional(Microsoft.CodeAnalysis.Operations.IConditionalOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditionalAccess(Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditionalAccessInstance(Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.Operations.IConstantPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConstructorBodyOperation(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeconstructionAssignment(Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDefaultCaseClause(Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDefaultValue(Microsoft.CodeAnalysis.Operations.IDefaultValueOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDelegateCreation(Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDiscardOperation(Microsoft.CodeAnalysis.Operations.IDiscardOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicIndexerAccess(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicInvocation(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicMemberReference(Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicObjectCreation(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEmpty(Microsoft.CodeAnalysis.Operations.IEmptyOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEnd(Microsoft.CodeAnalysis.Operations.IEndOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEventAssignment(Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEventReference(Microsoft.CodeAnalysis.Operations.IEventReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFieldInitializer(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFieldReference(Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowAnonymousFunction(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowCapture(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowCaptureReference(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForEachLoop(Microsoft.CodeAnalysis.Operations.IForEachLoopOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForLoop(Microsoft.CodeAnalysis.Operations.IForLoopOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForToLoop(Microsoft.CodeAnalysis.Operations.IForToLoopOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFunctionPointerInvocation(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitImplicitIndexerReference(Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIncrementOrDecrement(Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInlineArrayAccess(Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInstanceReference(Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedString(Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringAddition(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringAppend(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringHandlerArgumentPlaceholder(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringHandlerCreation(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolation(Microsoft.CodeAnalysis.Operations.IInterpolationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInvalid(Microsoft.CodeAnalysis.Operations.IInvalidOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInvocation(Microsoft.CodeAnalysis.Operations.IInvocationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsNull(Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsPattern(Microsoft.CodeAnalysis.Operations.IIsPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsType(Microsoft.CodeAnalysis.Operations.IIsTypeOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLabeled(Microsoft.CodeAnalysis.Operations.ILabeledOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitListPattern(Microsoft.CodeAnalysis.Operations.IListPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLiteral(Microsoft.CodeAnalysis.Operations.ILiteralOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLocalFunction(Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLocalReference(Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLock(Microsoft.CodeAnalysis.Operations.ILockOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMemberInitializer(Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMethodBodyOperation(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMethodReference(Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitNameOf(Microsoft.CodeAnalysis.Operations.INameOfOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitNegatedPattern(Microsoft.CodeAnalysis.Operations.INegatedPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitObjectCreation(Microsoft.CodeAnalysis.Operations.IObjectCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitObjectOrCollectionInitializer(Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitOmittedArgument(Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParameterInitializer(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParameterReference(Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParenthesized(Microsoft.CodeAnalysis.Operations.IParenthesizedOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPatternCaseClause(Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertyInitializer(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertyReference(Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertySubpattern(Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRaiseEvent(Microsoft.CodeAnalysis.Operations.IRaiseEventOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRangeCaseClause(Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRangeOperation(Microsoft.CodeAnalysis.Operations.IRangeOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReDim(Microsoft.CodeAnalysis.Operations.IReDimOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReDimClause(Microsoft.CodeAnalysis.Operations.IReDimClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRelationalCaseClause(Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReturn(Microsoft.CodeAnalysis.Operations.IReturnOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSimpleAssignment(Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSingleValueCaseClause(Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSizeOf(Microsoft.CodeAnalysis.Operations.ISizeOfOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.Operations.ISlicePatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSpread(Microsoft.CodeAnalysis.Operations.ISpreadOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitStaticLocalInitializationSemaphore(Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitStop(Microsoft.CodeAnalysis.Operations.IStopOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitch(Microsoft.CodeAnalysis.Operations.ISwitchOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchCase(Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitThrow(Microsoft.CodeAnalysis.Operations.IThrowOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTranslatedQuery(Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTry(Microsoft.CodeAnalysis.Operations.ITryOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTuple(Microsoft.CodeAnalysis.Operations.ITupleOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTupleBinaryOperator(Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypeOf(Microsoft.CodeAnalysis.Operations.ITypeOfOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypeParameterObjectCreation(Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypePattern(Microsoft.CodeAnalysis.Operations.ITypePatternOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUnaryOperator(Microsoft.CodeAnalysis.Operations.IUnaryOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUsing(Microsoft.CodeAnalysis.Operations.IUsingOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUsingDeclaration(Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUtf8String(Microsoft.CodeAnalysis.Operations.IUtf8StringOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclarationGroup(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitWhileLoop(Microsoft.CodeAnalysis.Operations.IWhileLoopOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitWith(Microsoft.CodeAnalysis.Operations.IWithOperation) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2 +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.#ctor +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.DefaultVisit(Microsoft.CodeAnalysis.IOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.Visit(Microsoft.CodeAnalysis.IOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAddressOf(Microsoft.CodeAnalysis.Operations.IAddressOfOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAnonymousFunction(Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAnonymousObjectCreation(Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArgument(Microsoft.CodeAnalysis.Operations.IArgumentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayCreation(Microsoft.CodeAnalysis.Operations.IArrayCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayElementReference(Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayInitializer(Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAttribute(Microsoft.CodeAnalysis.Operations.IAttributeOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAwait(Microsoft.CodeAnalysis.Operations.IAwaitOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBinaryOperator(Microsoft.CodeAnalysis.Operations.IBinaryOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBinaryPattern(Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBlock(Microsoft.CodeAnalysis.Operations.IBlockOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBranch(Microsoft.CodeAnalysis.Operations.IBranchOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCatchClause(Microsoft.CodeAnalysis.Operations.ICatchClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCaughtException(Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCoalesce(Microsoft.CodeAnalysis.Operations.ICoalesceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCoalesceAssignment(Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCollectionElementInitializer(Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCollectionExpression(Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCompoundAssignment(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditional(Microsoft.CodeAnalysis.Operations.IConditionalOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditionalAccess(Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditionalAccessInstance(Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConstantPattern(Microsoft.CodeAnalysis.Operations.IConstantPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConstructorBodyOperation(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeclarationExpression(Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeclarationPattern(Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeconstructionAssignment(Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDefaultCaseClause(Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDefaultValue(Microsoft.CodeAnalysis.Operations.IDefaultValueOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDelegateCreation(Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDiscardOperation(Microsoft.CodeAnalysis.Operations.IDiscardOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDiscardPattern(Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicIndexerAccess(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicInvocation(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicMemberReference(Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicObjectCreation(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEmpty(Microsoft.CodeAnalysis.Operations.IEmptyOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEnd(Microsoft.CodeAnalysis.Operations.IEndOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEventAssignment(Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEventReference(Microsoft.CodeAnalysis.Operations.IEventReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitExpressionStatement(Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFieldInitializer(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFieldReference(Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowAnonymousFunction(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowCapture(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowCaptureReference(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForEachLoop(Microsoft.CodeAnalysis.Operations.IForEachLoopOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForLoop(Microsoft.CodeAnalysis.Operations.IForLoopOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForToLoop(Microsoft.CodeAnalysis.Operations.IForToLoopOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFunctionPointerInvocation(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitImplicitIndexerReference(Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIncrementOrDecrement(Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInlineArrayAccess(Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInstanceReference(Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedString(Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringAddition(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringAppend(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringHandlerArgumentPlaceholder(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringHandlerCreation(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringText(Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolation(Microsoft.CodeAnalysis.Operations.IInterpolationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInvalid(Microsoft.CodeAnalysis.Operations.IInvalidOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInvocation(Microsoft.CodeAnalysis.Operations.IInvocationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsNull(Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsPattern(Microsoft.CodeAnalysis.Operations.IIsPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsType(Microsoft.CodeAnalysis.Operations.IIsTypeOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLabeled(Microsoft.CodeAnalysis.Operations.ILabeledOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitListPattern(Microsoft.CodeAnalysis.Operations.IListPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLiteral(Microsoft.CodeAnalysis.Operations.ILiteralOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLocalFunction(Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLocalReference(Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLock(Microsoft.CodeAnalysis.Operations.ILockOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMemberInitializer(Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMethodBodyOperation(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMethodReference(Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitNameOf(Microsoft.CodeAnalysis.Operations.INameOfOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitNegatedPattern(Microsoft.CodeAnalysis.Operations.INegatedPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitObjectCreation(Microsoft.CodeAnalysis.Operations.IObjectCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitObjectOrCollectionInitializer(Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitOmittedArgument(Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParameterInitializer(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParameterReference(Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParenthesized(Microsoft.CodeAnalysis.Operations.IParenthesizedOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPatternCaseClause(Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertyInitializer(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertyReference(Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertySubpattern(Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRaiseEvent(Microsoft.CodeAnalysis.Operations.IRaiseEventOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRangeCaseClause(Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRangeOperation(Microsoft.CodeAnalysis.Operations.IRangeOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReDim(Microsoft.CodeAnalysis.Operations.IReDimOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReDimClause(Microsoft.CodeAnalysis.Operations.IReDimClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRecursivePattern(Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRelationalCaseClause(Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRelationalPattern(Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReturn(Microsoft.CodeAnalysis.Operations.IReturnOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSimpleAssignment(Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSingleValueCaseClause(Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSizeOf(Microsoft.CodeAnalysis.Operations.ISizeOfOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSlicePattern(Microsoft.CodeAnalysis.Operations.ISlicePatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSpread(Microsoft.CodeAnalysis.Operations.ISpreadOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitStaticLocalInitializationSemaphore(Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitStop(Microsoft.CodeAnalysis.Operations.IStopOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitch(Microsoft.CodeAnalysis.Operations.ISwitchOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchCase(Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchExpression(Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitThrow(Microsoft.CodeAnalysis.Operations.IThrowOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTranslatedQuery(Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTry(Microsoft.CodeAnalysis.Operations.ITryOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTuple(Microsoft.CodeAnalysis.Operations.ITupleOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTupleBinaryOperator(Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypeOf(Microsoft.CodeAnalysis.Operations.ITypeOfOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypeParameterObjectCreation(Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypePattern(Microsoft.CodeAnalysis.Operations.ITypePatternOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUnaryOperator(Microsoft.CodeAnalysis.Operations.IUnaryOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUsing(Microsoft.CodeAnalysis.Operations.IUsingOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUsingDeclaration(Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUtf8String(Microsoft.CodeAnalysis.Operations.IUtf8StringOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclaration(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclarationGroup(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclarator(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitWhileLoop(Microsoft.CodeAnalysis.Operations.IWhileLoopOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitWith(Microsoft.CodeAnalysis.Operations.IWithOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationWalker +Microsoft.CodeAnalysis.Operations.OperationWalker.#ctor +Microsoft.CodeAnalysis.Operations.OperationWalker.DefaultVisit(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Operations.OperationWalker.Visit(Microsoft.CodeAnalysis.IOperation) +Microsoft.CodeAnalysis.Operations.OperationWalker`1 +Microsoft.CodeAnalysis.Operations.OperationWalker`1.#ctor +Microsoft.CodeAnalysis.Operations.OperationWalker`1.DefaultVisit(Microsoft.CodeAnalysis.IOperation,`0) +Microsoft.CodeAnalysis.Operations.OperationWalker`1.Visit(Microsoft.CodeAnalysis.IOperation,`0) +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.BitwiseNegation +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.False +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Hat +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Minus +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.None +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Not +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Plus +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.True +Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.value__ +Microsoft.CodeAnalysis.OptimizationLevel +Microsoft.CodeAnalysis.OptimizationLevel.Debug +Microsoft.CodeAnalysis.OptimizationLevel.Release +Microsoft.CodeAnalysis.OptimizationLevel.value__ +Microsoft.CodeAnalysis.Optional`1 +Microsoft.CodeAnalysis.Optional`1.#ctor(`0) +Microsoft.CodeAnalysis.Optional`1.ToString +Microsoft.CodeAnalysis.Optional`1.get_HasValue +Microsoft.CodeAnalysis.Optional`1.get_Value +Microsoft.CodeAnalysis.Optional`1.op_Implicit(`0)~Microsoft.CodeAnalysis.Optional{`0} +Microsoft.CodeAnalysis.OutputKind +Microsoft.CodeAnalysis.OutputKind.ConsoleApplication +Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary +Microsoft.CodeAnalysis.OutputKind.NetModule +Microsoft.CodeAnalysis.OutputKind.WindowsApplication +Microsoft.CodeAnalysis.OutputKind.WindowsRuntimeApplication +Microsoft.CodeAnalysis.OutputKind.WindowsRuntimeMetadata +Microsoft.CodeAnalysis.OutputKind.value__ +Microsoft.CodeAnalysis.ParseOptions +Microsoft.CodeAnalysis.ParseOptions.CommonWithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +Microsoft.CodeAnalysis.ParseOptions.CommonWithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +Microsoft.CodeAnalysis.ParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind) +Microsoft.CodeAnalysis.ParseOptions.Equals(System.Object) +Microsoft.CodeAnalysis.ParseOptions.EqualsHelper(Microsoft.CodeAnalysis.ParseOptions) +Microsoft.CodeAnalysis.ParseOptions.GetHashCode +Microsoft.CodeAnalysis.ParseOptions.GetHashCodeHelper +Microsoft.CodeAnalysis.ParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +Microsoft.CodeAnalysis.ParseOptions.WithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +Microsoft.CodeAnalysis.ParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind) +Microsoft.CodeAnalysis.ParseOptions.get_DocumentationMode +Microsoft.CodeAnalysis.ParseOptions.get_Errors +Microsoft.CodeAnalysis.ParseOptions.get_Features +Microsoft.CodeAnalysis.ParseOptions.get_Kind +Microsoft.CodeAnalysis.ParseOptions.get_Language +Microsoft.CodeAnalysis.ParseOptions.get_PreprocessorSymbolNames +Microsoft.CodeAnalysis.ParseOptions.get_SpecifiedKind +Microsoft.CodeAnalysis.ParseOptions.op_Equality(Microsoft.CodeAnalysis.ParseOptions,Microsoft.CodeAnalysis.ParseOptions) +Microsoft.CodeAnalysis.ParseOptions.op_Inequality(Microsoft.CodeAnalysis.ParseOptions,Microsoft.CodeAnalysis.ParseOptions) +Microsoft.CodeAnalysis.ParseOptions.set_DocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +Microsoft.CodeAnalysis.ParseOptions.set_Kind(Microsoft.CodeAnalysis.SourceCodeKind) +Microsoft.CodeAnalysis.ParseOptions.set_SpecifiedKind(Microsoft.CodeAnalysis.SourceCodeKind) +Microsoft.CodeAnalysis.Platform +Microsoft.CodeAnalysis.Platform.AnyCpu +Microsoft.CodeAnalysis.Platform.AnyCpu32BitPreferred +Microsoft.CodeAnalysis.Platform.Arm +Microsoft.CodeAnalysis.Platform.Arm64 +Microsoft.CodeAnalysis.Platform.Itanium +Microsoft.CodeAnalysis.Platform.X64 +Microsoft.CodeAnalysis.Platform.X86 +Microsoft.CodeAnalysis.Platform.value__ +Microsoft.CodeAnalysis.PortableExecutableReference +Microsoft.CodeAnalysis.PortableExecutableReference.#ctor(Microsoft.CodeAnalysis.MetadataReferenceProperties,System.String,Microsoft.CodeAnalysis.DocumentationProvider) +Microsoft.CodeAnalysis.PortableExecutableReference.CreateDocumentationProvider +Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadata +Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataId +Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataImpl +Microsoft.CodeAnalysis.PortableExecutableReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.PortableExecutableReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +Microsoft.CodeAnalysis.PortableExecutableReference.WithEmbedInteropTypes(System.Boolean) +Microsoft.CodeAnalysis.PortableExecutableReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.PortableExecutableReference.WithPropertiesImpl(Microsoft.CodeAnalysis.MetadataReferenceProperties) +Microsoft.CodeAnalysis.PortableExecutableReference.get_Display +Microsoft.CodeAnalysis.PortableExecutableReference.get_FilePath +Microsoft.CodeAnalysis.PreprocessingSymbolInfo +Microsoft.CodeAnalysis.PreprocessingSymbolInfo.Equals(Microsoft.CodeAnalysis.PreprocessingSymbolInfo) +Microsoft.CodeAnalysis.PreprocessingSymbolInfo.Equals(System.Object) +Microsoft.CodeAnalysis.PreprocessingSymbolInfo.GetHashCode +Microsoft.CodeAnalysis.PreprocessingSymbolInfo.get_IsDefined +Microsoft.CodeAnalysis.PreprocessingSymbolInfo.get_Symbol +Microsoft.CodeAnalysis.RefKind +Microsoft.CodeAnalysis.RefKind.In +Microsoft.CodeAnalysis.RefKind.None +Microsoft.CodeAnalysis.RefKind.Out +Microsoft.CodeAnalysis.RefKind.Ref +Microsoft.CodeAnalysis.RefKind.RefReadOnly +Microsoft.CodeAnalysis.RefKind.RefReadOnlyParameter +Microsoft.CodeAnalysis.RefKind.value__ +Microsoft.CodeAnalysis.ReportDiagnostic +Microsoft.CodeAnalysis.ReportDiagnostic.Default +Microsoft.CodeAnalysis.ReportDiagnostic.Error +Microsoft.CodeAnalysis.ReportDiagnostic.Hidden +Microsoft.CodeAnalysis.ReportDiagnostic.Info +Microsoft.CodeAnalysis.ReportDiagnostic.Suppress +Microsoft.CodeAnalysis.ReportDiagnostic.Warn +Microsoft.CodeAnalysis.ReportDiagnostic.value__ +Microsoft.CodeAnalysis.ResourceDescription +Microsoft.CodeAnalysis.ResourceDescription.#ctor(System.String,System.Func{System.IO.Stream},System.Boolean) +Microsoft.CodeAnalysis.ResourceDescription.#ctor(System.String,System.String,System.Func{System.IO.Stream},System.Boolean) +Microsoft.CodeAnalysis.RuleSetInclude +Microsoft.CodeAnalysis.RuleSetInclude.#ctor(System.String,Microsoft.CodeAnalysis.ReportDiagnostic) +Microsoft.CodeAnalysis.RuleSetInclude.LoadRuleSet(Microsoft.CodeAnalysis.RuleSet) +Microsoft.CodeAnalysis.RuleSetInclude.get_Action +Microsoft.CodeAnalysis.RuleSetInclude.get_IncludePath +Microsoft.CodeAnalysis.RuntimeCapability +Microsoft.CodeAnalysis.RuntimeCapability.ByRefFields +Microsoft.CodeAnalysis.RuntimeCapability.ByRefLikeGenerics +Microsoft.CodeAnalysis.RuntimeCapability.CovariantReturnsOfClasses +Microsoft.CodeAnalysis.RuntimeCapability.DefaultImplementationsOfInterfaces +Microsoft.CodeAnalysis.RuntimeCapability.InlineArrayTypes +Microsoft.CodeAnalysis.RuntimeCapability.NumericIntPtr +Microsoft.CodeAnalysis.RuntimeCapability.UnmanagedSignatureCallingConvention +Microsoft.CodeAnalysis.RuntimeCapability.VirtualStaticsInInterfaces +Microsoft.CodeAnalysis.RuntimeCapability.value__ +Microsoft.CodeAnalysis.SarifVersion +Microsoft.CodeAnalysis.SarifVersion.Default +Microsoft.CodeAnalysis.SarifVersion.Latest +Microsoft.CodeAnalysis.SarifVersion.Sarif1 +Microsoft.CodeAnalysis.SarifVersion.Sarif2 +Microsoft.CodeAnalysis.SarifVersion.value__ +Microsoft.CodeAnalysis.SarifVersionFacts +Microsoft.CodeAnalysis.SarifVersionFacts.TryParse(System.String,Microsoft.CodeAnalysis.SarifVersion@) +Microsoft.CodeAnalysis.ScopedKind +Microsoft.CodeAnalysis.ScopedKind.None +Microsoft.CodeAnalysis.ScopedKind.ScopedRef +Microsoft.CodeAnalysis.ScopedKind.ScopedValue +Microsoft.CodeAnalysis.ScopedKind.value__ +Microsoft.CodeAnalysis.ScriptCompilationInfo +Microsoft.CodeAnalysis.ScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.Compilation) +Microsoft.CodeAnalysis.ScriptCompilationInfo.get_GlobalsType +Microsoft.CodeAnalysis.ScriptCompilationInfo.get_PreviousScriptCompilation +Microsoft.CodeAnalysis.ScriptCompilationInfo.get_ReturnType +Microsoft.CodeAnalysis.SemanticModel +Microsoft.CodeAnalysis.SemanticModel.#ctor +Microsoft.CodeAnalysis.SemanticModel.AnalyzeControlFlowCore(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.AnalyzeControlFlowCore(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.AnalyzeDataFlowCore(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.AnalyzeDataFlowCore(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.GetAliasInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetConstantValue(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetConstantValueCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetDeclarationDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetDeclaredSymbolCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetDeclaredSymbolsCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetEnclosingSymbol(System.Int32,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetEnclosingSymbolCore(System.Int32,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetImportScopes(System.Int32,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetMemberGroupCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetMethodBodyDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetNullableContext(System.Int32) +Microsoft.CodeAnalysis.SemanticModel.GetOperation(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetOperationCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetPreprocessingSymbolInfo(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.GetPreprocessingSymbolInfoCore(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeAliasInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeSymbolInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeTypeInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +Microsoft.CodeAnalysis.SemanticModel.GetSymbolInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetSyntaxDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.GetTopmostNodeForDiagnosticAnalysis(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SemanticModel.GetTypeInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SemanticModel.IsAccessible(System.Int32,Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SemanticModel.IsAccessibleCore(System.Int32,Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SemanticModel.IsEventUsableAsField(System.Int32,Microsoft.CodeAnalysis.IEventSymbol) +Microsoft.CodeAnalysis.SemanticModel.IsEventUsableAsFieldCore(System.Int32,Microsoft.CodeAnalysis.IEventSymbol) +Microsoft.CodeAnalysis.SemanticModel.LookupBaseMembers(System.Int32,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupBaseMembersCore(System.Int32,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupLabels(System.Int32,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupLabelsCore(System.Int32,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupNamespacesAndTypes(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupNamespacesAndTypesCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupStaticMembers(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupStaticMembersCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +Microsoft.CodeAnalysis.SemanticModel.LookupSymbols(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Boolean) +Microsoft.CodeAnalysis.SemanticModel.LookupSymbolsCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Boolean) +Microsoft.CodeAnalysis.SemanticModel.get_Compilation +Microsoft.CodeAnalysis.SemanticModel.get_CompilationCore +Microsoft.CodeAnalysis.SemanticModel.get_IgnoresAccessibility +Microsoft.CodeAnalysis.SemanticModel.get_IsSpeculativeSemanticModel +Microsoft.CodeAnalysis.SemanticModel.get_Language +Microsoft.CodeAnalysis.SemanticModel.get_NullableAnalysisIsDisabled +Microsoft.CodeAnalysis.SemanticModel.get_OriginalPositionForSpeculation +Microsoft.CodeAnalysis.SemanticModel.get_ParentModel +Microsoft.CodeAnalysis.SemanticModel.get_ParentModelCore +Microsoft.CodeAnalysis.SemanticModel.get_RootCore +Microsoft.CodeAnalysis.SemanticModel.get_SyntaxTree +Microsoft.CodeAnalysis.SemanticModel.get_SyntaxTreeCore +Microsoft.CodeAnalysis.SemanticModelOptions +Microsoft.CodeAnalysis.SemanticModelOptions.DisableNullableAnalysis +Microsoft.CodeAnalysis.SemanticModelOptions.IgnoreAccessibility +Microsoft.CodeAnalysis.SemanticModelOptions.None +Microsoft.CodeAnalysis.SemanticModelOptions.value__ +Microsoft.CodeAnalysis.SeparatedSyntaxList +Microsoft.CodeAnalysis.SeparatedSyntaxList.Create``1(System.ReadOnlySpan{``0}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1 +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Add(`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Any +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Contains(`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.Equals(System.Object) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.GetHashCode +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.MoveNext +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.Reset +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.get_Current +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Equals(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Equals(System.Object) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.First +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.FirstOrDefault +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetEnumerator +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetHashCode +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetSeparator(System.Int32) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetSeparators +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetWithSeparators +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.IndexOf(System.Func{`0,System.Boolean}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.IndexOf(`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Insert(System.Int32,`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Last +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastIndexOf(System.Func{`0,System.Boolean}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastIndexOf(`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastOrDefault +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Remove(`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.RemoveAt(System.Int32) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Replace(`0,`0) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ReplaceRange(`0,System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ReplaceSeparator(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ToFullString +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ToString +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Count +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_FullSpan +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Item(System.Int32) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_SeparatorCount +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Span +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Equality(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0},Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Explicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode})~Microsoft.CodeAnalysis.SeparatedSyntaxList{`0} +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0})~Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode} +Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Inequality(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0},Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) +Microsoft.CodeAnalysis.SourceCodeKind +Microsoft.CodeAnalysis.SourceCodeKind.Interactive +Microsoft.CodeAnalysis.SourceCodeKind.Regular +Microsoft.CodeAnalysis.SourceCodeKind.Script +Microsoft.CodeAnalysis.SourceCodeKind.value__ +Microsoft.CodeAnalysis.SourceFileResolver +Microsoft.CodeAnalysis.SourceProductionContext +Microsoft.CodeAnalysis.SourceProductionContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.SourceProductionContext.AddSource(System.String,System.String) +Microsoft.CodeAnalysis.SourceProductionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +Microsoft.CodeAnalysis.SourceProductionContext.get_CancellationToken +Microsoft.CodeAnalysis.SourceReferenceResolver +Microsoft.CodeAnalysis.SpecialType +Microsoft.CodeAnalysis.SpecialType.Count +Microsoft.CodeAnalysis.SpecialType.None +Microsoft.CodeAnalysis.SpecialType.System_ArgIterator +Microsoft.CodeAnalysis.SpecialType.System_Array +Microsoft.CodeAnalysis.SpecialType.System_AsyncCallback +Microsoft.CodeAnalysis.SpecialType.System_Boolean +Microsoft.CodeAnalysis.SpecialType.System_Byte +Microsoft.CodeAnalysis.SpecialType.System_Char +Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_ICollection_T +Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IEnumerable_T +Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IEnumerator_T +Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IList_T +Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IReadOnlyCollection_T +Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IReadOnlyList_T +Microsoft.CodeAnalysis.SpecialType.System_Collections_IEnumerable +Microsoft.CodeAnalysis.SpecialType.System_Collections_IEnumerator +Microsoft.CodeAnalysis.SpecialType.System_DateTime +Microsoft.CodeAnalysis.SpecialType.System_Decimal +Microsoft.CodeAnalysis.SpecialType.System_Delegate +Microsoft.CodeAnalysis.SpecialType.System_Double +Microsoft.CodeAnalysis.SpecialType.System_Enum +Microsoft.CodeAnalysis.SpecialType.System_IAsyncResult +Microsoft.CodeAnalysis.SpecialType.System_IDisposable +Microsoft.CodeAnalysis.SpecialType.System_Int16 +Microsoft.CodeAnalysis.SpecialType.System_Int32 +Microsoft.CodeAnalysis.SpecialType.System_Int64 +Microsoft.CodeAnalysis.SpecialType.System_IntPtr +Microsoft.CodeAnalysis.SpecialType.System_MulticastDelegate +Microsoft.CodeAnalysis.SpecialType.System_Nullable_T +Microsoft.CodeAnalysis.SpecialType.System_Object +Microsoft.CodeAnalysis.SpecialType.System_RuntimeArgumentHandle +Microsoft.CodeAnalysis.SpecialType.System_RuntimeFieldHandle +Microsoft.CodeAnalysis.SpecialType.System_RuntimeMethodHandle +Microsoft.CodeAnalysis.SpecialType.System_RuntimeTypeHandle +Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute +Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_IsVolatile +Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute +Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_RuntimeFeature +Microsoft.CodeAnalysis.SpecialType.System_SByte +Microsoft.CodeAnalysis.SpecialType.System_Single +Microsoft.CodeAnalysis.SpecialType.System_String +Microsoft.CodeAnalysis.SpecialType.System_TypedReference +Microsoft.CodeAnalysis.SpecialType.System_UInt16 +Microsoft.CodeAnalysis.SpecialType.System_UInt32 +Microsoft.CodeAnalysis.SpecialType.System_UInt64 +Microsoft.CodeAnalysis.SpecialType.System_UIntPtr +Microsoft.CodeAnalysis.SpecialType.System_ValueType +Microsoft.CodeAnalysis.SpecialType.System_Void +Microsoft.CodeAnalysis.SpecialType.value__ +Microsoft.CodeAnalysis.SpeculativeBindingOption +Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsExpression +Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsTypeOrNamespace +Microsoft.CodeAnalysis.SpeculativeBindingOption.value__ +Microsoft.CodeAnalysis.StrongNameProvider +Microsoft.CodeAnalysis.SubsystemVersion +Microsoft.CodeAnalysis.SubsystemVersion.Create(System.Int32,System.Int32) +Microsoft.CodeAnalysis.SubsystemVersion.Equals(Microsoft.CodeAnalysis.SubsystemVersion) +Microsoft.CodeAnalysis.SubsystemVersion.Equals(System.Object) +Microsoft.CodeAnalysis.SubsystemVersion.GetHashCode +Microsoft.CodeAnalysis.SubsystemVersion.ToString +Microsoft.CodeAnalysis.SubsystemVersion.TryParse(System.String,Microsoft.CodeAnalysis.SubsystemVersion@) +Microsoft.CodeAnalysis.SubsystemVersion.get_IsValid +Microsoft.CodeAnalysis.SubsystemVersion.get_Major +Microsoft.CodeAnalysis.SubsystemVersion.get_Minor +Microsoft.CodeAnalysis.SubsystemVersion.get_None +Microsoft.CodeAnalysis.SubsystemVersion.get_Windows2000 +Microsoft.CodeAnalysis.SubsystemVersion.get_Windows7 +Microsoft.CodeAnalysis.SubsystemVersion.get_Windows8 +Microsoft.CodeAnalysis.SubsystemVersion.get_WindowsVista +Microsoft.CodeAnalysis.SubsystemVersion.get_WindowsXP +Microsoft.CodeAnalysis.SuppressionDescriptor +Microsoft.CodeAnalysis.SuppressionDescriptor.#ctor(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString) +Microsoft.CodeAnalysis.SuppressionDescriptor.#ctor(System.String,System.String,System.String) +Microsoft.CodeAnalysis.SuppressionDescriptor.Equals(Microsoft.CodeAnalysis.SuppressionDescriptor) +Microsoft.CodeAnalysis.SuppressionDescriptor.Equals(System.Object) +Microsoft.CodeAnalysis.SuppressionDescriptor.GetHashCode +Microsoft.CodeAnalysis.SuppressionDescriptor.get_Id +Microsoft.CodeAnalysis.SuppressionDescriptor.get_Justification +Microsoft.CodeAnalysis.SuppressionDescriptor.get_SuppressedDiagnosticId +Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle +Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameAndParameters +Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameAndSignature +Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameOnly +Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.value__ +Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle +Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.Default +Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.InstanceMethod +Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.StaticMethod +Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.value__ +Microsoft.CodeAnalysis.SymbolDisplayExtensions +Microsoft.CodeAnalysis.SymbolDisplayExtensions.ToDisplayString(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolDisplayPart}) +Microsoft.CodeAnalysis.SymbolDisplayFormat +Microsoft.CodeAnalysis.SymbolDisplayFormat.#ctor(Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle,Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle,Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions,Microsoft.CodeAnalysis.SymbolDisplayMemberOptions,Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle,Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle,Microsoft.CodeAnalysis.SymbolDisplayParameterOptions,Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle,Microsoft.CodeAnalysis.SymbolDisplayLocalOptions,Microsoft.CodeAnalysis.SymbolDisplayKindOptions,Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.AddGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.AddKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.AddLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.AddMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.AddMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.AddParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithGlobalNamespaceStyle(Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.WithParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_CSharpErrorMessageFormat +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_CSharpShortErrorMessageFormat +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_DelegateStyle +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_ExtensionMethodStyle +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_FullyQualifiedFormat +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_GenericsOptions +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_GlobalNamespaceStyle +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_KindOptions +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_LocalOptions +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MemberOptions +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MinimallyQualifiedFormat +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MiscellaneousOptions +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_ParameterOptions +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_PropertyStyle +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_TypeQualificationStyle +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_VisualBasicErrorMessageFormat +Microsoft.CodeAnalysis.SymbolDisplayFormat.get_VisualBasicShortErrorMessageFormat +Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions +Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeTypeConstraints +Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeTypeParameters +Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeVariance +Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.None +Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.value__ +Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle +Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.Included +Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.Omitted +Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining +Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.value__ +Microsoft.CodeAnalysis.SymbolDisplayKindOptions +Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeMemberKeyword +Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeNamespaceKeyword +Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeTypeKeyword +Microsoft.CodeAnalysis.SymbolDisplayKindOptions.None +Microsoft.CodeAnalysis.SymbolDisplayKindOptions.value__ +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeConstantValue +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeModifiers +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeRef +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeType +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.None +Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.value__ +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeAccessibility +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeConstantValue +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeContainingType +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeExplicitInterface +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeModifiers +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeParameters +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeRef +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeType +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.None +Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.value__ +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.CollapseTupleTypes +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.ExpandNullable +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.ExpandValueTuple +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.IncludeNotNullableReferenceTypeModifier +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.None +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.RemoveAttributeSuffix +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseAsterisksInMultiDimensionalArrays +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseErrorTypeSymbolName +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseSpecialTypes +Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.value__ +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeDefaultValue +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeExtensionThis +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeModifiers +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeName +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeOptionalBrackets +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeParamsRefOut +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeType +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.None +Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.value__ +Microsoft.CodeAnalysis.SymbolDisplayPart +Microsoft.CodeAnalysis.SymbolDisplayPart.#ctor(Microsoft.CodeAnalysis.SymbolDisplayPartKind,Microsoft.CodeAnalysis.ISymbol,System.String) +Microsoft.CodeAnalysis.SymbolDisplayPart.ToString +Microsoft.CodeAnalysis.SymbolDisplayPart.get_Kind +Microsoft.CodeAnalysis.SymbolDisplayPart.get_Symbol +Microsoft.CodeAnalysis.SymbolDisplayPartKind +Microsoft.CodeAnalysis.SymbolDisplayPartKind.AliasName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.AnonymousTypeIndicator +Microsoft.CodeAnalysis.SymbolDisplayPartKind.AssemblyName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.ClassName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.ConstantName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.DelegateName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.EnumMemberName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.EnumName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.ErrorTypeName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.EventName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.ExtensionMethodName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.FieldName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.InterfaceName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.Keyword +Microsoft.CodeAnalysis.SymbolDisplayPartKind.LabelName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.LineBreak +Microsoft.CodeAnalysis.SymbolDisplayPartKind.LocalName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.MethodName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.ModuleName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.NamespaceName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.NumericLiteral +Microsoft.CodeAnalysis.SymbolDisplayPartKind.Operator +Microsoft.CodeAnalysis.SymbolDisplayPartKind.ParameterName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.PropertyName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.Punctuation +Microsoft.CodeAnalysis.SymbolDisplayPartKind.RangeVariableName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordClassName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordStructName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.Space +Microsoft.CodeAnalysis.SymbolDisplayPartKind.StringLiteral +Microsoft.CodeAnalysis.SymbolDisplayPartKind.StructName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.Text +Microsoft.CodeAnalysis.SymbolDisplayPartKind.TypeParameterName +Microsoft.CodeAnalysis.SymbolDisplayPartKind.value__ +Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle +Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.NameOnly +Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.ShowReadWriteDescriptor +Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.value__ +Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle +Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameAndContainingTypes +Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces +Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameOnly +Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.value__ +Microsoft.CodeAnalysis.SymbolEqualityComparer +Microsoft.CodeAnalysis.SymbolEqualityComparer.Default +Microsoft.CodeAnalysis.SymbolEqualityComparer.Equals(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SymbolEqualityComparer.GetHashCode(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SymbolEqualityComparer.IncludeNullability +Microsoft.CodeAnalysis.SymbolFilter +Microsoft.CodeAnalysis.SymbolFilter.All +Microsoft.CodeAnalysis.SymbolFilter.Member +Microsoft.CodeAnalysis.SymbolFilter.Namespace +Microsoft.CodeAnalysis.SymbolFilter.None +Microsoft.CodeAnalysis.SymbolFilter.Type +Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember +Microsoft.CodeAnalysis.SymbolFilter.value__ +Microsoft.CodeAnalysis.SymbolInfo +Microsoft.CodeAnalysis.SymbolInfo.Equals(Microsoft.CodeAnalysis.SymbolInfo) +Microsoft.CodeAnalysis.SymbolInfo.Equals(System.Object) +Microsoft.CodeAnalysis.SymbolInfo.GetHashCode +Microsoft.CodeAnalysis.SymbolInfo.get_CandidateReason +Microsoft.CodeAnalysis.SymbolInfo.get_CandidateSymbols +Microsoft.CodeAnalysis.SymbolInfo.get_Symbol +Microsoft.CodeAnalysis.SymbolKind +Microsoft.CodeAnalysis.SymbolKind.Alias +Microsoft.CodeAnalysis.SymbolKind.ArrayType +Microsoft.CodeAnalysis.SymbolKind.Assembly +Microsoft.CodeAnalysis.SymbolKind.Discard +Microsoft.CodeAnalysis.SymbolKind.DynamicType +Microsoft.CodeAnalysis.SymbolKind.ErrorType +Microsoft.CodeAnalysis.SymbolKind.Event +Microsoft.CodeAnalysis.SymbolKind.Field +Microsoft.CodeAnalysis.SymbolKind.FunctionPointerType +Microsoft.CodeAnalysis.SymbolKind.Label +Microsoft.CodeAnalysis.SymbolKind.Local +Microsoft.CodeAnalysis.SymbolKind.Method +Microsoft.CodeAnalysis.SymbolKind.NamedType +Microsoft.CodeAnalysis.SymbolKind.Namespace +Microsoft.CodeAnalysis.SymbolKind.NetModule +Microsoft.CodeAnalysis.SymbolKind.Parameter +Microsoft.CodeAnalysis.SymbolKind.PointerType +Microsoft.CodeAnalysis.SymbolKind.Preprocessing +Microsoft.CodeAnalysis.SymbolKind.Property +Microsoft.CodeAnalysis.SymbolKind.RangeVariable +Microsoft.CodeAnalysis.SymbolKind.TypeParameter +Microsoft.CodeAnalysis.SymbolKind.value__ +Microsoft.CodeAnalysis.SymbolVisitor +Microsoft.CodeAnalysis.SymbolVisitor.#ctor +Microsoft.CodeAnalysis.SymbolVisitor.DefaultVisit(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SymbolVisitor.Visit(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitField(Microsoft.CodeAnalysis.IFieldSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol) +Microsoft.CodeAnalysis.SymbolVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1 +Microsoft.CodeAnalysis.SymbolVisitor`1.#ctor +Microsoft.CodeAnalysis.SymbolVisitor`1.DefaultVisit(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.Visit(Microsoft.CodeAnalysis.ISymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitField(Microsoft.CodeAnalysis.IFieldSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`1.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol) +Microsoft.CodeAnalysis.SymbolVisitor`2 +Microsoft.CodeAnalysis.SymbolVisitor`2.#ctor +Microsoft.CodeAnalysis.SymbolVisitor`2.DefaultVisit(Microsoft.CodeAnalysis.ISymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.Visit(Microsoft.CodeAnalysis.ISymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitField(Microsoft.CodeAnalysis.IFieldSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol,`0) +Microsoft.CodeAnalysis.SymbolVisitor`2.get_DefaultResult +Microsoft.CodeAnalysis.SyntaxAnnotation +Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor +Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor(System.String) +Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor(System.String,System.String) +Microsoft.CodeAnalysis.SyntaxAnnotation.Equals(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxAnnotation.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxAnnotation.GetHashCode +Microsoft.CodeAnalysis.SyntaxAnnotation.get_Data +Microsoft.CodeAnalysis.SyntaxAnnotation.get_ElasticAnnotation +Microsoft.CodeAnalysis.SyntaxAnnotation.get_Kind +Microsoft.CodeAnalysis.SyntaxAnnotation.op_Equality(Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxAnnotation.op_Inequality(Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxContextReceiverCreator +Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.#ctor(System.Object,System.IntPtr) +Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.BeginInvoke(System.AsyncCallback,System.Object) +Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.EndInvoke(System.IAsyncResult) +Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.Invoke +Microsoft.CodeAnalysis.SyntaxList +Microsoft.CodeAnalysis.SyntaxList.Create``1(System.ReadOnlySpan{``0}) +Microsoft.CodeAnalysis.SyntaxList`1 +Microsoft.CodeAnalysis.SyntaxList`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SyntaxList`1.#ctor(`0) +Microsoft.CodeAnalysis.SyntaxList`1.Add(`0) +Microsoft.CodeAnalysis.SyntaxList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SyntaxList`1.Any +Microsoft.CodeAnalysis.SyntaxList`1.Enumerator +Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.GetHashCode +Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.MoveNext +Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.Reset +Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.get_Current +Microsoft.CodeAnalysis.SyntaxList`1.Equals(Microsoft.CodeAnalysis.SyntaxList{`0}) +Microsoft.CodeAnalysis.SyntaxList`1.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxList`1.First +Microsoft.CodeAnalysis.SyntaxList`1.FirstOrDefault +Microsoft.CodeAnalysis.SyntaxList`1.GetEnumerator +Microsoft.CodeAnalysis.SyntaxList`1.GetHashCode +Microsoft.CodeAnalysis.SyntaxList`1.IndexOf(System.Func{`0,System.Boolean}) +Microsoft.CodeAnalysis.SyntaxList`1.IndexOf(`0) +Microsoft.CodeAnalysis.SyntaxList`1.Insert(System.Int32,`0) +Microsoft.CodeAnalysis.SyntaxList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SyntaxList`1.Last +Microsoft.CodeAnalysis.SyntaxList`1.LastIndexOf(System.Func{`0,System.Boolean}) +Microsoft.CodeAnalysis.SyntaxList`1.LastIndexOf(`0) +Microsoft.CodeAnalysis.SyntaxList`1.LastOrDefault +Microsoft.CodeAnalysis.SyntaxList`1.Remove(`0) +Microsoft.CodeAnalysis.SyntaxList`1.RemoveAt(System.Int32) +Microsoft.CodeAnalysis.SyntaxList`1.Replace(`0,`0) +Microsoft.CodeAnalysis.SyntaxList`1.ReplaceRange(`0,System.Collections.Generic.IEnumerable{`0}) +Microsoft.CodeAnalysis.SyntaxList`1.ToFullString +Microsoft.CodeAnalysis.SyntaxList`1.ToString +Microsoft.CodeAnalysis.SyntaxList`1.get_Count +Microsoft.CodeAnalysis.SyntaxList`1.get_FullSpan +Microsoft.CodeAnalysis.SyntaxList`1.get_Item(System.Int32) +Microsoft.CodeAnalysis.SyntaxList`1.get_Span +Microsoft.CodeAnalysis.SyntaxList`1.op_Equality(Microsoft.CodeAnalysis.SyntaxList{`0},Microsoft.CodeAnalysis.SyntaxList{`0}) +Microsoft.CodeAnalysis.SyntaxList`1.op_Explicit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode})~Microsoft.CodeAnalysis.SyntaxList{`0} +Microsoft.CodeAnalysis.SyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SyntaxList{`0})~Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode} +Microsoft.CodeAnalysis.SyntaxList`1.op_Inequality(Microsoft.CodeAnalysis.SyntaxList{`0},Microsoft.CodeAnalysis.SyntaxList{`0}) +Microsoft.CodeAnalysis.SyntaxNode +Microsoft.CodeAnalysis.SyntaxNode.Ancestors(System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.AncestorsAndSelf(System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.ChildNodes +Microsoft.CodeAnalysis.SyntaxNode.ChildNodesAndTokens +Microsoft.CodeAnalysis.SyntaxNode.ChildThatContainsPosition(System.Int32) +Microsoft.CodeAnalysis.SyntaxNode.ChildTokens +Microsoft.CodeAnalysis.SyntaxNode.Contains(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxNode.ContainsDirective(System.Int32) +Microsoft.CodeAnalysis.SyntaxNode.CopyAnnotationsTo``1(``0) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodes(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodes(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndSelf(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndSelf(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokens(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokens(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokensAndSelf(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokensAndSelf(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantTokens(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantTokens(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantTrivia(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.DescendantTrivia(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.EquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxNode.FindNode(Microsoft.CodeAnalysis.Text.TextSpan,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.FindToken(System.Int32,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.FindTokenCore(System.Int32,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.FindTokenCore(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) +Microsoft.CodeAnalysis.SyntaxNode.FindTrivia(System.Int32,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.FindTrivia(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) +Microsoft.CodeAnalysis.SyntaxNode.FindTriviaCore(System.Int32,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf``1(System.Func{``0,System.Boolean},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf``2(System.Func{``0,``1,System.Boolean},``1,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodes(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodes(System.String) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(System.String) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(System.String[]) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTokens(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTokens(System.String) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(System.String) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(System.String[]) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.SyntaxNode.GetAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxNode.GetDiagnostics +Microsoft.CodeAnalysis.SyntaxNode.GetFirstToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.GetLastToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.GetLeadingTrivia +Microsoft.CodeAnalysis.SyntaxNode.GetLocation +Microsoft.CodeAnalysis.SyntaxNode.GetRedAtZero``1(``0@) +Microsoft.CodeAnalysis.SyntaxNode.GetRed``1(``0@,System.Int32) +Microsoft.CodeAnalysis.SyntaxNode.GetReference +Microsoft.CodeAnalysis.SyntaxNode.GetText(System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +Microsoft.CodeAnalysis.SyntaxNode.GetTrailingTrivia +Microsoft.CodeAnalysis.SyntaxNode.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxNode.HasAnnotations(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.SyntaxNode.HasAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxNode.InsertNodesInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.InsertTokensInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.InsertTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxNode.IsPartOfStructuredTrivia +Microsoft.CodeAnalysis.SyntaxNode.NormalizeWhitespaceCore(System.String,System.String,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNode.RemoveNodesCore(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) +Microsoft.CodeAnalysis.SyntaxNode.ReplaceCore``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNode.ReplaceNodeInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxNode.ReplaceTokenInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxNode.ReplaceTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNode.SerializeTo(System.IO.Stream,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxNode.ToFullString +Microsoft.CodeAnalysis.SyntaxNode.ToString +Microsoft.CodeAnalysis.SyntaxNode.WriteTo(System.IO.TextWriter) +Microsoft.CodeAnalysis.SyntaxNode.get_ContainsAnnotations +Microsoft.CodeAnalysis.SyntaxNode.get_ContainsDiagnostics +Microsoft.CodeAnalysis.SyntaxNode.get_ContainsDirectives +Microsoft.CodeAnalysis.SyntaxNode.get_ContainsSkippedText +Microsoft.CodeAnalysis.SyntaxNode.get_FullSpan +Microsoft.CodeAnalysis.SyntaxNode.get_HasLeadingTrivia +Microsoft.CodeAnalysis.SyntaxNode.get_HasStructuredTrivia +Microsoft.CodeAnalysis.SyntaxNode.get_HasTrailingTrivia +Microsoft.CodeAnalysis.SyntaxNode.get_IsMissing +Microsoft.CodeAnalysis.SyntaxNode.get_IsStructuredTrivia +Microsoft.CodeAnalysis.SyntaxNode.get_KindText +Microsoft.CodeAnalysis.SyntaxNode.get_Language +Microsoft.CodeAnalysis.SyntaxNode.get_Parent +Microsoft.CodeAnalysis.SyntaxNode.get_ParentTrivia +Microsoft.CodeAnalysis.SyntaxNode.get_RawKind +Microsoft.CodeAnalysis.SyntaxNode.get_Span +Microsoft.CodeAnalysis.SyntaxNode.get_SpanStart +Microsoft.CodeAnalysis.SyntaxNode.get_SyntaxTree +Microsoft.CodeAnalysis.SyntaxNode.get_SyntaxTreeCore +Microsoft.CodeAnalysis.SyntaxNodeExtensions +Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNode``1(Microsoft.CodeAnalysis.SyntaxNode,``0) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNodes``1(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{``0}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNodes``1(Microsoft.CodeAnalysis.SyntaxNode,``0) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertNodesAfter``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertNodesBefore``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTokensAfter``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTokensBefore``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTriviaAfter``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTriviaBefore``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.NormalizeWhitespace``1(``0,System.String,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.NormalizeWhitespace``1(``0,System.String,System.String,System.Boolean) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.RemoveNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxRemoveOptions) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.RemoveNodes``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNodes``2(``0,System.Collections.Generic.IEnumerable{``1},System.Func{``1,``1,Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceSyntax``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceToken``1(``0,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceToken``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTokens``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.TrackNodes``1(``0,Microsoft.CodeAnalysis.SyntaxNode[]) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.TrackNodes``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTriviaFrom``1(``0,Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutLeadingTrivia``1(``0) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrailingTrivia``1(``0) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrivia(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrivia``1(``0) +Microsoft.CodeAnalysis.SyntaxNodeOrToken +Microsoft.CodeAnalysis.SyntaxNodeOrToken.AsNode +Microsoft.CodeAnalysis.SyntaxNodeOrToken.AsToken +Microsoft.CodeAnalysis.SyntaxNodeOrToken.ChildNodesAndTokens +Microsoft.CodeAnalysis.SyntaxNodeOrToken.Equals(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetDiagnostics +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetFirstChildIndexSpanningPosition(Microsoft.CodeAnalysis.SyntaxNode,System.Int32) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetHashCode +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetLeadingTrivia +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetLocation +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetNextSibling +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetPreviousSibling +Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetTrailingTrivia +Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotations(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.ToFullString +Microsoft.CodeAnalysis.SyntaxNodeOrToken.ToString +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithLeadingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithTrailingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.WriteTo(System.IO.TextWriter) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsAnnotations +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsDiagnostics +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsDirectives +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_FullSpan +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_HasLeadingTrivia +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_HasTrailingTrivia +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsMissing +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsNode +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsToken +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Language +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Parent +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_RawKind +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Span +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_SpanStart +Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_SyntaxTree +Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Equality(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Explicit(Microsoft.CodeAnalysis.SyntaxNodeOrToken)~Microsoft.CodeAnalysis.SyntaxNode +Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Explicit(Microsoft.CodeAnalysis.SyntaxNodeOrToken)~Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Implicit(Microsoft.CodeAnalysis.SyntaxNode)~Microsoft.CodeAnalysis.SyntaxNodeOrToken +Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Implicit(Microsoft.CodeAnalysis.SyntaxToken)~Microsoft.CodeAnalysis.SyntaxNodeOrToken +Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Inequality(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxNodeOrToken[]) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Add(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Any +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.GetHashCode +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.MoveNext +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.get_Current +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Equals(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.First +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.FirstOrDefault +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.GetEnumerator +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.GetHashCode +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.IndexOf(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Last +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.LastOrDefault +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Remove(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.RemoveAt(System.Int32) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Replace(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxNodeOrToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ToFullString +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ToString +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Count +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_FullSpan +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Item(System.Int32) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Span +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.op_Equality(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList,Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.op_Inequality(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList,Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +Microsoft.CodeAnalysis.SyntaxReceiverCreator +Microsoft.CodeAnalysis.SyntaxReceiverCreator.#ctor(System.Object,System.IntPtr) +Microsoft.CodeAnalysis.SyntaxReceiverCreator.BeginInvoke(System.AsyncCallback,System.Object) +Microsoft.CodeAnalysis.SyntaxReceiverCreator.EndInvoke(System.IAsyncResult) +Microsoft.CodeAnalysis.SyntaxReceiverCreator.Invoke +Microsoft.CodeAnalysis.SyntaxReference +Microsoft.CodeAnalysis.SyntaxReference.#ctor +Microsoft.CodeAnalysis.SyntaxReference.GetSyntax(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxReference.GetSyntaxAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxReference.get_Span +Microsoft.CodeAnalysis.SyntaxReference.get_SyntaxTree +Microsoft.CodeAnalysis.SyntaxRemoveOptions +Microsoft.CodeAnalysis.SyntaxRemoveOptions.AddElasticMarker +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepDirectives +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepEndOfLine +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepExteriorTrivia +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepLeadingTrivia +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepNoTrivia +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepTrailingTrivia +Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepUnbalancedDirectives +Microsoft.CodeAnalysis.SyntaxRemoveOptions.value__ +Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.SyntaxToken.CopyAnnotationsTo(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxToken.Equals(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxToken.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxToken.GetAllTrivia +Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) +Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.String[]) +Microsoft.CodeAnalysis.SyntaxToken.GetDiagnostics +Microsoft.CodeAnalysis.SyntaxToken.GetHashCode +Microsoft.CodeAnalysis.SyntaxToken.GetLocation +Microsoft.CodeAnalysis.SyntaxToken.GetNextToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.SyntaxToken.GetPreviousToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.SyntaxToken.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxToken.HasAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxToken.HasAnnotations(System.String[]) +Microsoft.CodeAnalysis.SyntaxToken.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxToken.IsPartOfStructuredTrivia +Microsoft.CodeAnalysis.SyntaxToken.ToFullString +Microsoft.CodeAnalysis.SyntaxToken.ToString +Microsoft.CodeAnalysis.SyntaxToken.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.SyntaxToken.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxToken.WithTriviaFrom(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxToken.WriteTo(System.IO.TextWriter) +Microsoft.CodeAnalysis.SyntaxToken.get_ContainsAnnotations +Microsoft.CodeAnalysis.SyntaxToken.get_ContainsDiagnostics +Microsoft.CodeAnalysis.SyntaxToken.get_ContainsDirectives +Microsoft.CodeAnalysis.SyntaxToken.get_FullSpan +Microsoft.CodeAnalysis.SyntaxToken.get_HasLeadingTrivia +Microsoft.CodeAnalysis.SyntaxToken.get_HasStructuredTrivia +Microsoft.CodeAnalysis.SyntaxToken.get_HasTrailingTrivia +Microsoft.CodeAnalysis.SyntaxToken.get_IsMissing +Microsoft.CodeAnalysis.SyntaxToken.get_Language +Microsoft.CodeAnalysis.SyntaxToken.get_LeadingTrivia +Microsoft.CodeAnalysis.SyntaxToken.get_Parent +Microsoft.CodeAnalysis.SyntaxToken.get_RawKind +Microsoft.CodeAnalysis.SyntaxToken.get_Span +Microsoft.CodeAnalysis.SyntaxToken.get_SpanStart +Microsoft.CodeAnalysis.SyntaxToken.get_SyntaxTree +Microsoft.CodeAnalysis.SyntaxToken.get_Text +Microsoft.CodeAnalysis.SyntaxToken.get_TrailingTrivia +Microsoft.CodeAnalysis.SyntaxToken.get_Value +Microsoft.CodeAnalysis.SyntaxToken.get_ValueText +Microsoft.CodeAnalysis.SyntaxToken.op_Equality(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxToken.op_Inequality(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList +Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxToken[]) +Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxTokenList.Add(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxTokenList.Any +Microsoft.CodeAnalysis.SyntaxTokenList.Create(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator +Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.GetHashCode +Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.MoveNext +Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.get_Current +Microsoft.CodeAnalysis.SyntaxTokenList.Equals(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.SyntaxTokenList.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTokenList.First +Microsoft.CodeAnalysis.SyntaxTokenList.GetEnumerator +Microsoft.CodeAnalysis.SyntaxTokenList.GetHashCode +Microsoft.CodeAnalysis.SyntaxTokenList.IndexOf(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxTokenList.Last +Microsoft.CodeAnalysis.SyntaxTokenList.Remove(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.RemoveAt(System.Int32) +Microsoft.CodeAnalysis.SyntaxTokenList.Replace(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTokenList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +Microsoft.CodeAnalysis.SyntaxTokenList.Reverse +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.#ctor(Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.GetHashCode +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.MoveNext +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.get_Current +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Equals(Microsoft.CodeAnalysis.SyntaxTokenList.Reversed) +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.GetEnumerator +Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.GetHashCode +Microsoft.CodeAnalysis.SyntaxTokenList.ToFullString +Microsoft.CodeAnalysis.SyntaxTokenList.ToString +Microsoft.CodeAnalysis.SyntaxTokenList.get_Count +Microsoft.CodeAnalysis.SyntaxTokenList.get_FullSpan +Microsoft.CodeAnalysis.SyntaxTokenList.get_Item(System.Int32) +Microsoft.CodeAnalysis.SyntaxTokenList.get_Span +Microsoft.CodeAnalysis.SyntaxTokenList.op_Equality(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.SyntaxTokenList.op_Inequality(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) +Microsoft.CodeAnalysis.SyntaxTree +Microsoft.CodeAnalysis.SyntaxTree.#ctor +Microsoft.CodeAnalysis.SyntaxTree.EmptyDiagnosticOptions +Microsoft.CodeAnalysis.SyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.SyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree) +Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetLineMappings(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetLineVisibility(System.Int32,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.SyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetReference(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxTree.GetRoot(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetRootAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetRootCore(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetText(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.GetTextAsync(System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTree.HasHiddenRegions +Microsoft.CodeAnalysis.SyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +Microsoft.CodeAnalysis.SyntaxTree.ToString +Microsoft.CodeAnalysis.SyntaxTree.TryGetRoot(Microsoft.CodeAnalysis.SyntaxNode@) +Microsoft.CodeAnalysis.SyntaxTree.TryGetRootCore(Microsoft.CodeAnalysis.SyntaxNode@) +Microsoft.CodeAnalysis.SyntaxTree.TryGetText(Microsoft.CodeAnalysis.Text.SourceText@) +Microsoft.CodeAnalysis.SyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.SyntaxTree.WithDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +Microsoft.CodeAnalysis.SyntaxTree.WithFilePath(System.String) +Microsoft.CodeAnalysis.SyntaxTree.WithRootAndOptions(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions) +Microsoft.CodeAnalysis.SyntaxTree.get_DiagnosticOptions +Microsoft.CodeAnalysis.SyntaxTree.get_Encoding +Microsoft.CodeAnalysis.SyntaxTree.get_FilePath +Microsoft.CodeAnalysis.SyntaxTree.get_HasCompilationUnitRoot +Microsoft.CodeAnalysis.SyntaxTree.get_Length +Microsoft.CodeAnalysis.SyntaxTree.get_Options +Microsoft.CodeAnalysis.SyntaxTree.get_OptionsCore +Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider +Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.#ctor +Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.IsGenerated(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.TryGetDiagnosticValue(Microsoft.CodeAnalysis.SyntaxTree,System.String,System.Threading.CancellationToken,Microsoft.CodeAnalysis.ReportDiagnostic@) +Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.TryGetGlobalDiagnosticValue(System.String,System.Threading.CancellationToken,Microsoft.CodeAnalysis.ReportDiagnostic@) +Microsoft.CodeAnalysis.SyntaxTrivia +Microsoft.CodeAnalysis.SyntaxTrivia.CopyAnnotationsTo(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTrivia.Equals(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTrivia.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTrivia.GetAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxTrivia.GetAnnotations(System.String[]) +Microsoft.CodeAnalysis.SyntaxTrivia.GetDiagnostics +Microsoft.CodeAnalysis.SyntaxTrivia.GetHashCode +Microsoft.CodeAnalysis.SyntaxTrivia.GetLocation +Microsoft.CodeAnalysis.SyntaxTrivia.GetStructure +Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotations(System.String[]) +Microsoft.CodeAnalysis.SyntaxTrivia.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTrivia.IsPartOfStructuredTrivia +Microsoft.CodeAnalysis.SyntaxTrivia.ToFullString +Microsoft.CodeAnalysis.SyntaxTrivia.ToString +Microsoft.CodeAnalysis.SyntaxTrivia.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.SyntaxTrivia.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(System.String) +Microsoft.CodeAnalysis.SyntaxTrivia.WriteTo(System.IO.TextWriter) +Microsoft.CodeAnalysis.SyntaxTrivia.get_ContainsDiagnostics +Microsoft.CodeAnalysis.SyntaxTrivia.get_FullSpan +Microsoft.CodeAnalysis.SyntaxTrivia.get_HasStructure +Microsoft.CodeAnalysis.SyntaxTrivia.get_IsDirective +Microsoft.CodeAnalysis.SyntaxTrivia.get_Language +Microsoft.CodeAnalysis.SyntaxTrivia.get_RawKind +Microsoft.CodeAnalysis.SyntaxTrivia.get_Span +Microsoft.CodeAnalysis.SyntaxTrivia.get_SpanStart +Microsoft.CodeAnalysis.SyntaxTrivia.get_SyntaxTree +Microsoft.CodeAnalysis.SyntaxTrivia.get_Token +Microsoft.CodeAnalysis.SyntaxTrivia.op_Equality(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTrivia.op_Inequality(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList +Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(Microsoft.CodeAnalysis.SyntaxTrivia[]) +Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxTriviaList.Add(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxTriviaList.Any +Microsoft.CodeAnalysis.SyntaxTriviaList.Create(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxTriviaList.ElementAt(System.Int32) +Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator +Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator.MoveNext +Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator.get_Current +Microsoft.CodeAnalysis.SyntaxTriviaList.Equals(Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxTriviaList.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTriviaList.First +Microsoft.CodeAnalysis.SyntaxTriviaList.GetEnumerator +Microsoft.CodeAnalysis.SyntaxTriviaList.GetHashCode +Microsoft.CodeAnalysis.SyntaxTriviaList.IndexOf(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxTriviaList.Last +Microsoft.CodeAnalysis.SyntaxTriviaList.Remove(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.RemoveAt(System.Int32) +Microsoft.CodeAnalysis.SyntaxTriviaList.Replace(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxTriviaList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +Microsoft.CodeAnalysis.SyntaxTriviaList.Reverse +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.#ctor(Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator.MoveNext +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator.get_Current +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Equals(Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed) +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Equals(System.Object) +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.GetEnumerator +Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.GetHashCode +Microsoft.CodeAnalysis.SyntaxTriviaList.ToFullString +Microsoft.CodeAnalysis.SyntaxTriviaList.ToString +Microsoft.CodeAnalysis.SyntaxTriviaList.get_Count +Microsoft.CodeAnalysis.SyntaxTriviaList.get_Empty +Microsoft.CodeAnalysis.SyntaxTriviaList.get_FullSpan +Microsoft.CodeAnalysis.SyntaxTriviaList.get_Item(System.Int32) +Microsoft.CodeAnalysis.SyntaxTriviaList.get_Span +Microsoft.CodeAnalysis.SyntaxTriviaList.op_Equality(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxTriviaList.op_Inequality(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.SyntaxTriviaList) +Microsoft.CodeAnalysis.SyntaxValueProvider +Microsoft.CodeAnalysis.SyntaxValueProvider.CreateSyntaxProvider``1(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken,System.Boolean},System.Func{Microsoft.CodeAnalysis.GeneratorSyntaxContext,System.Threading.CancellationToken,``0}) +Microsoft.CodeAnalysis.SyntaxValueProvider.ForAttributeWithMetadataName``1(System.String,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken,System.Boolean},System.Func{Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext,System.Threading.CancellationToken,``0}) +Microsoft.CodeAnalysis.SyntaxWalker +Microsoft.CodeAnalysis.SyntaxWalker.#ctor(Microsoft.CodeAnalysis.SyntaxWalkerDepth) +Microsoft.CodeAnalysis.SyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode) +Microsoft.CodeAnalysis.SyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) +Microsoft.CodeAnalysis.SyntaxWalker.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) +Microsoft.CodeAnalysis.SyntaxWalker.get_Depth +Microsoft.CodeAnalysis.SyntaxWalkerDepth +Microsoft.CodeAnalysis.SyntaxWalkerDepth.Node +Microsoft.CodeAnalysis.SyntaxWalkerDepth.StructuredTrivia +Microsoft.CodeAnalysis.SyntaxWalkerDepth.Token +Microsoft.CodeAnalysis.SyntaxWalkerDepth.Trivia +Microsoft.CodeAnalysis.SyntaxWalkerDepth.value__ +Microsoft.CodeAnalysis.Text.LinePosition +Microsoft.CodeAnalysis.Text.LinePosition.#ctor(System.Int32,System.Int32) +Microsoft.CodeAnalysis.Text.LinePosition.CompareTo(Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.Equals(Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.Equals(System.Object) +Microsoft.CodeAnalysis.Text.LinePosition.GetHashCode +Microsoft.CodeAnalysis.Text.LinePosition.ToString +Microsoft.CodeAnalysis.Text.LinePosition.get_Character +Microsoft.CodeAnalysis.Text.LinePosition.get_Line +Microsoft.CodeAnalysis.Text.LinePosition.get_Zero +Microsoft.CodeAnalysis.Text.LinePosition.op_Equality(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.op_GreaterThan(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.op_GreaterThanOrEqual(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.op_Inequality(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.op_LessThan(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePosition.op_LessThanOrEqual(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePositionSpan +Microsoft.CodeAnalysis.Text.LinePositionSpan.#ctor(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.LinePositionSpan.Equals(Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.Text.LinePositionSpan.Equals(System.Object) +Microsoft.CodeAnalysis.Text.LinePositionSpan.GetHashCode +Microsoft.CodeAnalysis.Text.LinePositionSpan.ToString +Microsoft.CodeAnalysis.Text.LinePositionSpan.get_End +Microsoft.CodeAnalysis.Text.LinePositionSpan.get_Start +Microsoft.CodeAnalysis.Text.LinePositionSpan.op_Equality(Microsoft.CodeAnalysis.Text.LinePositionSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.Text.LinePositionSpan.op_Inequality(Microsoft.CodeAnalysis.Text.LinePositionSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.Text.SourceHashAlgorithm +Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.None +Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha1 +Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha256 +Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.value__ +Microsoft.CodeAnalysis.Text.SourceText +Microsoft.CodeAnalysis.Text.SourceText.#ctor(System.Collections.Immutable.ImmutableArray{System.Byte},Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,Microsoft.CodeAnalysis.Text.SourceTextContainer) +Microsoft.CodeAnalysis.Text.SourceText.ContentEquals(Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.Text.SourceText.ContentEqualsImpl(Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.Text.SourceText.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) +Microsoft.CodeAnalysis.Text.SourceText.From(System.Byte[],System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean) +Microsoft.CodeAnalysis.Text.SourceText.From(System.Byte[],System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.Stream,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean) +Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.Stream,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean,System.Boolean) +Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.TextReader,System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +Microsoft.CodeAnalysis.Text.SourceText.From(System.String,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +Microsoft.CodeAnalysis.Text.SourceText.GetChangeRanges(Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.Text.SourceText.GetChecksum +Microsoft.CodeAnalysis.Text.SourceText.GetContentHash +Microsoft.CodeAnalysis.Text.SourceText.GetLinesCore +Microsoft.CodeAnalysis.Text.SourceText.GetSubText(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.SourceText.GetSubText(System.Int32) +Microsoft.CodeAnalysis.Text.SourceText.GetTextChanges(Microsoft.CodeAnalysis.Text.SourceText) +Microsoft.CodeAnalysis.Text.SourceText.Replace(Microsoft.CodeAnalysis.Text.TextSpan,System.String) +Microsoft.CodeAnalysis.Text.SourceText.Replace(System.Int32,System.Int32,System.String) +Microsoft.CodeAnalysis.Text.SourceText.ToString +Microsoft.CodeAnalysis.Text.SourceText.ToString(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.SourceText.WithChanges(Microsoft.CodeAnalysis.Text.TextChange[]) +Microsoft.CodeAnalysis.Text.SourceText.WithChanges(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChange}) +Microsoft.CodeAnalysis.Text.SourceText.Write(System.IO.TextWriter,Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Text.SourceText.Write(System.IO.TextWriter,System.Threading.CancellationToken) +Microsoft.CodeAnalysis.Text.SourceText.get_CanBeEmbedded +Microsoft.CodeAnalysis.Text.SourceText.get_ChecksumAlgorithm +Microsoft.CodeAnalysis.Text.SourceText.get_Container +Microsoft.CodeAnalysis.Text.SourceText.get_Encoding +Microsoft.CodeAnalysis.Text.SourceText.get_Item(System.Int32) +Microsoft.CodeAnalysis.Text.SourceText.get_Length +Microsoft.CodeAnalysis.Text.SourceText.get_Lines +Microsoft.CodeAnalysis.Text.SourceTextContainer +Microsoft.CodeAnalysis.Text.SourceTextContainer.#ctor +Microsoft.CodeAnalysis.Text.SourceTextContainer.add_TextChanged(System.EventHandler{Microsoft.CodeAnalysis.Text.TextChangeEventArgs}) +Microsoft.CodeAnalysis.Text.SourceTextContainer.get_CurrentText +Microsoft.CodeAnalysis.Text.SourceTextContainer.remove_TextChanged(System.EventHandler{Microsoft.CodeAnalysis.Text.TextChangeEventArgs}) +Microsoft.CodeAnalysis.Text.TextChange +Microsoft.CodeAnalysis.Text.TextChange.#ctor(Microsoft.CodeAnalysis.Text.TextSpan,System.String) +Microsoft.CodeAnalysis.Text.TextChange.Equals(Microsoft.CodeAnalysis.Text.TextChange) +Microsoft.CodeAnalysis.Text.TextChange.Equals(System.Object) +Microsoft.CodeAnalysis.Text.TextChange.GetHashCode +Microsoft.CodeAnalysis.Text.TextChange.ToString +Microsoft.CodeAnalysis.Text.TextChange.get_NewText +Microsoft.CodeAnalysis.Text.TextChange.get_NoChanges +Microsoft.CodeAnalysis.Text.TextChange.get_Span +Microsoft.CodeAnalysis.Text.TextChange.op_Equality(Microsoft.CodeAnalysis.Text.TextChange,Microsoft.CodeAnalysis.Text.TextChange) +Microsoft.CodeAnalysis.Text.TextChange.op_Implicit(Microsoft.CodeAnalysis.Text.TextChange)~Microsoft.CodeAnalysis.Text.TextChangeRange +Microsoft.CodeAnalysis.Text.TextChange.op_Inequality(Microsoft.CodeAnalysis.Text.TextChange,Microsoft.CodeAnalysis.Text.TextChange) +Microsoft.CodeAnalysis.Text.TextChangeEventArgs +Microsoft.CodeAnalysis.Text.TextChangeEventArgs.#ctor(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.TextChangeRange[]) +Microsoft.CodeAnalysis.Text.TextChangeEventArgs.#ctor(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.SourceText,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChangeRange}) +Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_Changes +Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_NewText +Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_OldText +Microsoft.CodeAnalysis.Text.TextChangeRange +Microsoft.CodeAnalysis.Text.TextChangeRange.#ctor(Microsoft.CodeAnalysis.Text.TextSpan,System.Int32) +Microsoft.CodeAnalysis.Text.TextChangeRange.Collapse(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChangeRange}) +Microsoft.CodeAnalysis.Text.TextChangeRange.Equals(Microsoft.CodeAnalysis.Text.TextChangeRange) +Microsoft.CodeAnalysis.Text.TextChangeRange.Equals(System.Object) +Microsoft.CodeAnalysis.Text.TextChangeRange.GetHashCode +Microsoft.CodeAnalysis.Text.TextChangeRange.ToString +Microsoft.CodeAnalysis.Text.TextChangeRange.get_NewLength +Microsoft.CodeAnalysis.Text.TextChangeRange.get_NoChanges +Microsoft.CodeAnalysis.Text.TextChangeRange.get_Span +Microsoft.CodeAnalysis.Text.TextChangeRange.op_Equality(Microsoft.CodeAnalysis.Text.TextChangeRange,Microsoft.CodeAnalysis.Text.TextChangeRange) +Microsoft.CodeAnalysis.Text.TextChangeRange.op_Inequality(Microsoft.CodeAnalysis.Text.TextChangeRange,Microsoft.CodeAnalysis.Text.TextChangeRange) +Microsoft.CodeAnalysis.Text.TextLine +Microsoft.CodeAnalysis.Text.TextLine.Equals(Microsoft.CodeAnalysis.Text.TextLine) +Microsoft.CodeAnalysis.Text.TextLine.Equals(System.Object) +Microsoft.CodeAnalysis.Text.TextLine.FromSpan(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextLine.GetHashCode +Microsoft.CodeAnalysis.Text.TextLine.ToString +Microsoft.CodeAnalysis.Text.TextLine.get_End +Microsoft.CodeAnalysis.Text.TextLine.get_EndIncludingLineBreak +Microsoft.CodeAnalysis.Text.TextLine.get_LineNumber +Microsoft.CodeAnalysis.Text.TextLine.get_Span +Microsoft.CodeAnalysis.Text.TextLine.get_SpanIncludingLineBreak +Microsoft.CodeAnalysis.Text.TextLine.get_Start +Microsoft.CodeAnalysis.Text.TextLine.get_Text +Microsoft.CodeAnalysis.Text.TextLine.op_Equality(Microsoft.CodeAnalysis.Text.TextLine,Microsoft.CodeAnalysis.Text.TextLine) +Microsoft.CodeAnalysis.Text.TextLine.op_Inequality(Microsoft.CodeAnalysis.Text.TextLine,Microsoft.CodeAnalysis.Text.TextLine) +Microsoft.CodeAnalysis.Text.TextLineCollection +Microsoft.CodeAnalysis.Text.TextLineCollection.#ctor +Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator +Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.Equals(System.Object) +Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.GetHashCode +Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.MoveNext +Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.get_Current +Microsoft.CodeAnalysis.Text.TextLineCollection.GetEnumerator +Microsoft.CodeAnalysis.Text.TextLineCollection.GetLineFromPosition(System.Int32) +Microsoft.CodeAnalysis.Text.TextLineCollection.GetLinePosition(System.Int32) +Microsoft.CodeAnalysis.Text.TextLineCollection.GetLinePositionSpan(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextLineCollection.GetPosition(Microsoft.CodeAnalysis.Text.LinePosition) +Microsoft.CodeAnalysis.Text.TextLineCollection.GetTextSpan(Microsoft.CodeAnalysis.Text.LinePositionSpan) +Microsoft.CodeAnalysis.Text.TextLineCollection.IndexOf(System.Int32) +Microsoft.CodeAnalysis.Text.TextLineCollection.get_Count +Microsoft.CodeAnalysis.Text.TextLineCollection.get_Item(System.Int32) +Microsoft.CodeAnalysis.Text.TextSpan +Microsoft.CodeAnalysis.Text.TextSpan.#ctor(System.Int32,System.Int32) +Microsoft.CodeAnalysis.Text.TextSpan.CompareTo(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.Contains(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.Contains(System.Int32) +Microsoft.CodeAnalysis.Text.TextSpan.Equals(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.Equals(System.Object) +Microsoft.CodeAnalysis.Text.TextSpan.FromBounds(System.Int32,System.Int32) +Microsoft.CodeAnalysis.Text.TextSpan.GetHashCode +Microsoft.CodeAnalysis.Text.TextSpan.Intersection(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.IntersectsWith(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.IntersectsWith(System.Int32) +Microsoft.CodeAnalysis.Text.TextSpan.Overlap(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.OverlapsWith(Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.ToString +Microsoft.CodeAnalysis.Text.TextSpan.get_End +Microsoft.CodeAnalysis.Text.TextSpan.get_IsEmpty +Microsoft.CodeAnalysis.Text.TextSpan.get_Length +Microsoft.CodeAnalysis.Text.TextSpan.get_Start +Microsoft.CodeAnalysis.Text.TextSpan.op_Equality(Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.Text.TextSpan.op_Inequality(Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.TextSpan) +Microsoft.CodeAnalysis.TypeInfo +Microsoft.CodeAnalysis.TypeInfo.Equals(Microsoft.CodeAnalysis.TypeInfo) +Microsoft.CodeAnalysis.TypeInfo.Equals(System.Object) +Microsoft.CodeAnalysis.TypeInfo.GetHashCode +Microsoft.CodeAnalysis.TypeInfo.get_ConvertedNullability +Microsoft.CodeAnalysis.TypeInfo.get_ConvertedType +Microsoft.CodeAnalysis.TypeInfo.get_Nullability +Microsoft.CodeAnalysis.TypeInfo.get_Type +Microsoft.CodeAnalysis.TypeKind +Microsoft.CodeAnalysis.TypeKind.Array +Microsoft.CodeAnalysis.TypeKind.Class +Microsoft.CodeAnalysis.TypeKind.Delegate +Microsoft.CodeAnalysis.TypeKind.Dynamic +Microsoft.CodeAnalysis.TypeKind.Enum +Microsoft.CodeAnalysis.TypeKind.Error +Microsoft.CodeAnalysis.TypeKind.FunctionPointer +Microsoft.CodeAnalysis.TypeKind.Interface +Microsoft.CodeAnalysis.TypeKind.Module +Microsoft.CodeAnalysis.TypeKind.Pointer +Microsoft.CodeAnalysis.TypeKind.Struct +Microsoft.CodeAnalysis.TypeKind.Structure +Microsoft.CodeAnalysis.TypeKind.Submission +Microsoft.CodeAnalysis.TypeKind.TypeParameter +Microsoft.CodeAnalysis.TypeKind.Unknown +Microsoft.CodeAnalysis.TypeKind.value__ +Microsoft.CodeAnalysis.TypeParameterKind +Microsoft.CodeAnalysis.TypeParameterKind.Cref +Microsoft.CodeAnalysis.TypeParameterKind.Method +Microsoft.CodeAnalysis.TypeParameterKind.Type +Microsoft.CodeAnalysis.TypeParameterKind.value__ +Microsoft.CodeAnalysis.TypedConstant +Microsoft.CodeAnalysis.TypedConstant.Equals(Microsoft.CodeAnalysis.TypedConstant) +Microsoft.CodeAnalysis.TypedConstant.Equals(System.Object) +Microsoft.CodeAnalysis.TypedConstant.GetHashCode +Microsoft.CodeAnalysis.TypedConstant.get_IsNull +Microsoft.CodeAnalysis.TypedConstant.get_Kind +Microsoft.CodeAnalysis.TypedConstant.get_Type +Microsoft.CodeAnalysis.TypedConstant.get_Value +Microsoft.CodeAnalysis.TypedConstant.get_Values +Microsoft.CodeAnalysis.TypedConstantKind +Microsoft.CodeAnalysis.TypedConstantKind.Array +Microsoft.CodeAnalysis.TypedConstantKind.Enum +Microsoft.CodeAnalysis.TypedConstantKind.Error +Microsoft.CodeAnalysis.TypedConstantKind.Primitive +Microsoft.CodeAnalysis.TypedConstantKind.Type +Microsoft.CodeAnalysis.TypedConstantKind.value__ +Microsoft.CodeAnalysis.UnresolvedMetadataReference +Microsoft.CodeAnalysis.UnresolvedMetadataReference.get_Display +Microsoft.CodeAnalysis.UnresolvedMetadataReference.get_Reference +Microsoft.CodeAnalysis.VarianceKind +Microsoft.CodeAnalysis.VarianceKind.In +Microsoft.CodeAnalysis.VarianceKind.None +Microsoft.CodeAnalysis.VarianceKind.Out +Microsoft.CodeAnalysis.VarianceKind.value__ +Microsoft.CodeAnalysis.WellKnownDiagnosticTags +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.AnalyzerException +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Build +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CompilationEnd +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Compiler +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CustomObsolete +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CustomSeverityConfigurable +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.EditAndContinue +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.NotConfigurable +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Telemetry +Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Unnecessary +Microsoft.CodeAnalysis.WellKnownGeneratorInputs +Microsoft.CodeAnalysis.WellKnownGeneratorInputs.AdditionalTexts +Microsoft.CodeAnalysis.WellKnownGeneratorInputs.AnalyzerConfigOptions +Microsoft.CodeAnalysis.WellKnownGeneratorInputs.Compilation +Microsoft.CodeAnalysis.WellKnownGeneratorInputs.MetadataReferences +Microsoft.CodeAnalysis.WellKnownGeneratorInputs.ParseOptions +Microsoft.CodeAnalysis.WellKnownGeneratorOutputs +Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.ImplementationSourceOutput +Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.SourceOutput +Microsoft.CodeAnalysis.WellKnownMemberNames +Microsoft.CodeAnalysis.WellKnownMemberNames.AdditionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.BitwiseAndOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.BitwiseOrOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedAdditionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedDecrementOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedDivisionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedExplicitConversionName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedIncrementOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedMultiplyOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedSubtractionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedUnaryNegationOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CollectionInitializerAddMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.ConcatenateOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.CountPropertyName +Microsoft.CodeAnalysis.WellKnownMemberNames.CurrentPropertyName +Microsoft.CodeAnalysis.WellKnownMemberNames.DeconstructMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.DecrementOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.DefaultScriptClassName +Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateBeginInvokeName +Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateEndInvokeName +Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateInvokeName +Microsoft.CodeAnalysis.WellKnownMemberNames.DestructorName +Microsoft.CodeAnalysis.WellKnownMemberNames.DisposeAsyncMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.DisposeMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.DivisionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.EntryPointMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.EnumBackingFieldName +Microsoft.CodeAnalysis.WellKnownMemberNames.EqualityOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.ExclusiveOrOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.ExplicitConversionName +Microsoft.CodeAnalysis.WellKnownMemberNames.ExponentOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.FalseOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.GetAsyncEnumeratorMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.GetAwaiter +Microsoft.CodeAnalysis.WellKnownMemberNames.GetEnumeratorMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.GetResult +Microsoft.CodeAnalysis.WellKnownMemberNames.GreaterThanOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.GreaterThanOrEqualOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.ImplicitConversionName +Microsoft.CodeAnalysis.WellKnownMemberNames.IncrementOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.Indexer +Microsoft.CodeAnalysis.WellKnownMemberNames.InequalityOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.InstanceConstructorName +Microsoft.CodeAnalysis.WellKnownMemberNames.IntegerDivisionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.IsCompleted +Microsoft.CodeAnalysis.WellKnownMemberNames.LeftShiftOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.LengthPropertyName +Microsoft.CodeAnalysis.WellKnownMemberNames.LessThanOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.LessThanOrEqualOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.LikeOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalAndOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalNotOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalOrOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.ModulusOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextAsyncMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.MultiplyOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectEquals +Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectGetHashCode +Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectToString +Microsoft.CodeAnalysis.WellKnownMemberNames.OnCompleted +Microsoft.CodeAnalysis.WellKnownMemberNames.OnesComplementOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.PrintMembersMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.RightShiftOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.SliceMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.StaticConstructorName +Microsoft.CodeAnalysis.WellKnownMemberNames.SubtractionOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.TopLevelStatementsEntryPointMethodName +Microsoft.CodeAnalysis.WellKnownMemberNames.TopLevelStatementsEntryPointTypeName +Microsoft.CodeAnalysis.WellKnownMemberNames.TrueOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.UnaryNegationOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.UnaryPlusOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.UnsignedLeftShiftOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.UnsignedRightShiftOperatorName +Microsoft.CodeAnalysis.WellKnownMemberNames.ValuePropertyName +Microsoft.CodeAnalysis.XmlFileResolver +Microsoft.CodeAnalysis.XmlFileResolver.#ctor(System.String) +Microsoft.CodeAnalysis.XmlFileResolver.Equals(System.Object) +Microsoft.CodeAnalysis.XmlFileResolver.FileExists(System.String) +Microsoft.CodeAnalysis.XmlFileResolver.GetHashCode +Microsoft.CodeAnalysis.XmlFileResolver.OpenRead(System.String) +Microsoft.CodeAnalysis.XmlFileResolver.ResolveReference(System.String,System.String) +Microsoft.CodeAnalysis.XmlFileResolver.get_BaseDirectory +Microsoft.CodeAnalysis.XmlFileResolver.get_Default +Microsoft.CodeAnalysis.XmlReferenceResolver \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt new file mode 100644 index 0000000000000..048eb78842382 --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt @@ -0,0 +1,799 @@ +# Generated, do not update manually +System.Collections.Frozen.FrozenDictionary +System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Frozen.FrozenDictionary`2 +System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1 +System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.ContainsKey(`2) +System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.TryGetValue(`2,`1@) +System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.get_Dictionary +System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.get_Item(`2) +System.Collections.Frozen.FrozenDictionary`2.ContainsKey(`0) +System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) +System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Span{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Frozen.FrozenDictionary`2.Enumerator +System.Collections.Frozen.FrozenDictionary`2.Enumerator.MoveNext +System.Collections.Frozen.FrozenDictionary`2.Enumerator.get_Current +System.Collections.Frozen.FrozenDictionary`2.GetAlternateLookup``1 +System.Collections.Frozen.FrozenDictionary`2.GetEnumerator +System.Collections.Frozen.FrozenDictionary`2.GetValueRefOrNullRef(`0) +System.Collections.Frozen.FrozenDictionary`2.TryGetAlternateLookup``1(System.Collections.Frozen.FrozenDictionary{`0,`1}.AlternateLookup{``0}@) +System.Collections.Frozen.FrozenDictionary`2.TryGetValue(`0,`1@) +System.Collections.Frozen.FrozenDictionary`2.get_Comparer +System.Collections.Frozen.FrozenDictionary`2.get_Count +System.Collections.Frozen.FrozenDictionary`2.get_Empty +System.Collections.Frozen.FrozenDictionary`2.get_Item(`0) +System.Collections.Frozen.FrozenDictionary`2.get_Keys +System.Collections.Frozen.FrozenDictionary`2.get_Values +System.Collections.Frozen.FrozenSet +System.Collections.Frozen.FrozenSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},System.ReadOnlySpan{``0}) +System.Collections.Frozen.FrozenSet.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Frozen.FrozenSet.ToFrozenSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Frozen.FrozenSet`1 +System.Collections.Frozen.FrozenSet`1.AlternateLookup`1 +System.Collections.Frozen.FrozenSet`1.AlternateLookup`1.Contains(`1) +System.Collections.Frozen.FrozenSet`1.AlternateLookup`1.TryGetValue(`1,`0@) +System.Collections.Frozen.FrozenSet`1.AlternateLookup`1.get_Set +System.Collections.Frozen.FrozenSet`1.Contains(`0) +System.Collections.Frozen.FrozenSet`1.CopyTo(System.Span{`0}) +System.Collections.Frozen.FrozenSet`1.CopyTo(`0[],System.Int32) +System.Collections.Frozen.FrozenSet`1.Enumerator +System.Collections.Frozen.FrozenSet`1.Enumerator.MoveNext +System.Collections.Frozen.FrozenSet`1.Enumerator.get_Current +System.Collections.Frozen.FrozenSet`1.GetAlternateLookup``1 +System.Collections.Frozen.FrozenSet`1.GetEnumerator +System.Collections.Frozen.FrozenSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Frozen.FrozenSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Frozen.FrozenSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Frozen.FrozenSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Frozen.FrozenSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Frozen.FrozenSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Frozen.FrozenSet`1.TryGetAlternateLookup``1(System.Collections.Frozen.FrozenSet{`0}.AlternateLookup{``0}@) +System.Collections.Frozen.FrozenSet`1.TryGetValue(`0,`0@) +System.Collections.Frozen.FrozenSet`1.get_Comparer +System.Collections.Frozen.FrozenSet`1.get_Count +System.Collections.Frozen.FrozenSet`1.get_Empty +System.Collections.Frozen.FrozenSet`1.get_Items +System.Collections.Immutable.IImmutableDictionary`2 +System.Collections.Immutable.IImmutableDictionary`2.Add(`0,`1) +System.Collections.Immutable.IImmutableDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.IImmutableDictionary`2.Clear +System.Collections.Immutable.IImmutableDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.IImmutableDictionary`2.Remove(`0) +System.Collections.Immutable.IImmutableDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableDictionary`2.SetItem(`0,`1) +System.Collections.Immutable.IImmutableDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.IImmutableDictionary`2.TryGetKey(`0,`0@) +System.Collections.Immutable.IImmutableList`1 +System.Collections.Immutable.IImmutableList`1.Add(`0) +System.Collections.Immutable.IImmutableList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableList`1.Clear +System.Collections.Immutable.IImmutableList`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.IImmutableList`1.Insert(System.Int32,`0) +System.Collections.Immutable.IImmutableList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableList`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.IImmutableList`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.IImmutableList`1.RemoveAll(System.Predicate{`0}) +System.Collections.Immutable.IImmutableList`1.RemoveAt(System.Int32) +System.Collections.Immutable.IImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.IImmutableList`1.RemoveRange(System.Int32,System.Int32) +System.Collections.Immutable.IImmutableList`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.IImmutableList`1.SetItem(System.Int32,`0) +System.Collections.Immutable.IImmutableQueue`1 +System.Collections.Immutable.IImmutableQueue`1.Clear +System.Collections.Immutable.IImmutableQueue`1.Dequeue +System.Collections.Immutable.IImmutableQueue`1.Enqueue(`0) +System.Collections.Immutable.IImmutableQueue`1.Peek +System.Collections.Immutable.IImmutableQueue`1.get_IsEmpty +System.Collections.Immutable.IImmutableSet`1 +System.Collections.Immutable.IImmutableSet`1.Add(`0) +System.Collections.Immutable.IImmutableSet`1.Clear +System.Collections.Immutable.IImmutableSet`1.Contains(`0) +System.Collections.Immutable.IImmutableSet`1.Except(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.Remove(`0) +System.Collections.Immutable.IImmutableSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableSet`1.TryGetValue(`0,`0@) +System.Collections.Immutable.IImmutableSet`1.Union(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.IImmutableStack`1 +System.Collections.Immutable.IImmutableStack`1.Clear +System.Collections.Immutable.IImmutableStack`1.Peek +System.Collections.Immutable.IImmutableStack`1.Pop +System.Collections.Immutable.IImmutableStack`1.Push(`0) +System.Collections.Immutable.IImmutableStack`1.get_IsEmpty +System.Collections.Immutable.ImmutableArray +System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,``0) +System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,``0,System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},``0) +System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},``0,System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableArray.CreateBuilder``1 +System.Collections.Immutable.ImmutableArray.CreateBuilder``1(System.Int32) +System.Collections.Immutable.ImmutableArray.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableArray.CreateRange``2(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1}) +System.Collections.Immutable.ImmutableArray.CreateRange``2(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,System.Func{``0,``1}) +System.Collections.Immutable.ImmutableArray.CreateRange``3(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1,``2},``1) +System.Collections.Immutable.ImmutableArray.CreateRange``3(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,System.Func{``0,``1,``2},``1) +System.Collections.Immutable.ImmutableArray.Create``1 +System.Collections.Immutable.ImmutableArray.Create``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableArray.Create``1(System.Span{``0}) +System.Collections.Immutable.ImmutableArray.Create``1(``0) +System.Collections.Immutable.ImmutableArray.Create``1(``0,``0) +System.Collections.Immutable.ImmutableArray.Create``1(``0,``0,``0) +System.Collections.Immutable.ImmutableArray.Create``1(``0,``0,``0,``0) +System.Collections.Immutable.ImmutableArray.Create``1(``0[]) +System.Collections.Immutable.ImmutableArray.Create``1(``0[],System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Span{``0}) +System.Collections.Immutable.ImmutableArray`1 +System.Collections.Immutable.ImmutableArray`1.Add(`0) +System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Immutable.ImmutableArray{`0},System.Int32) +System.Collections.Immutable.ImmutableArray`1.AddRange(System.ReadOnlySpan{`0}) +System.Collections.Immutable.ImmutableArray`1.AddRange(`0[]) +System.Collections.Immutable.ImmutableArray`1.AddRange(`0[],System.Int32) +System.Collections.Immutable.ImmutableArray`1.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Collections.Immutable.ImmutableArray`1.AddRange``1(``0[]) +System.Collections.Immutable.ImmutableArray`1.AsMemory +System.Collections.Immutable.ImmutableArray`1.AsSpan +System.Collections.Immutable.ImmutableArray`1.AsSpan(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.AsSpan(System.Range) +System.Collections.Immutable.ImmutableArray`1.As``1 +System.Collections.Immutable.ImmutableArray`1.Builder +System.Collections.Immutable.ImmutableArray`1.Builder.Add(`0) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0},System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0}.Builder) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.ReadOnlySpan{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(`0[]) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(`0[],System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(``0[]) +System.Collections.Immutable.ImmutableArray`1.Builder.Clear +System.Collections.Immutable.ImmutableArray`1.Builder.Contains(`0) +System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(System.Span{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(`0[]) +System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(`0[],System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.DrainToImmutable +System.Collections.Immutable.ImmutableArray`1.Builder.GetEnumerator +System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0) +System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.Insert(System.Int32,`0) +System.Collections.Immutable.ImmutableArray`1.Builder.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.InsertRange(System.Int32,System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.ItemRef(System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0) +System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.MoveToImmutable +System.Collections.Immutable.ImmutableArray`1.Builder.Remove(`0) +System.Collections.Immutable.ImmutableArray`1.Builder.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.RemoveAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.RemoveAt(System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.Replace(`0,`0) +System.Collections.Immutable.ImmutableArray`1.Builder.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.Reverse +System.Collections.Immutable.ImmutableArray`1.Builder.Sort +System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Comparison{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Builder.ToArray +System.Collections.Immutable.ImmutableArray`1.Builder.ToImmutable +System.Collections.Immutable.ImmutableArray`1.Builder.get_Capacity +System.Collections.Immutable.ImmutableArray`1.Builder.get_Count +System.Collections.Immutable.ImmutableArray`1.Builder.get_Item(System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.set_Capacity(System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.set_Count(System.Int32) +System.Collections.Immutable.ImmutableArray`1.Builder.set_Item(System.Int32,`0) +System.Collections.Immutable.ImmutableArray`1.CastArray``1 +System.Collections.Immutable.ImmutableArray`1.CastUp``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Collections.Immutable.ImmutableArray`1.Clear +System.Collections.Immutable.ImmutableArray`1.Contains(`0) +System.Collections.Immutable.ImmutableArray`1.Contains(`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.CopyTo(System.Span{`0}) +System.Collections.Immutable.ImmutableArray`1.CopyTo(`0[]) +System.Collections.Immutable.ImmutableArray`1.CopyTo(`0[],System.Int32) +System.Collections.Immutable.ImmutableArray`1.Empty +System.Collections.Immutable.ImmutableArray`1.Enumerator +System.Collections.Immutable.ImmutableArray`1.Enumerator.MoveNext +System.Collections.Immutable.ImmutableArray`1.Enumerator.get_Current +System.Collections.Immutable.ImmutableArray`1.Equals(System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.Equals(System.Object) +System.Collections.Immutable.ImmutableArray`1.GetEnumerator +System.Collections.Immutable.ImmutableArray`1.GetHashCode +System.Collections.Immutable.ImmutableArray`1.IndexOf(`0) +System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32) +System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Insert(System.Int32,`0) +System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.ReadOnlySpan{`0}) +System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,`0[]) +System.Collections.Immutable.ImmutableArray`1.ItemRef(System.Int32) +System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0) +System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32) +System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.OfType``1 +System.Collections.Immutable.ImmutableArray`1.Remove(`0) +System.Collections.Immutable.ImmutableArray`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveAt(System.Int32) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.ReadOnlySpan{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.RemoveRange(`0[],System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Replace(`0,`0) +System.Collections.Immutable.ImmutableArray`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.SetItem(System.Int32,`0) +System.Collections.Immutable.ImmutableArray`1.Slice(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableArray`1.Sort +System.Collections.Immutable.ImmutableArray`1.Sort(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.Sort(System.Comparison{`0}) +System.Collections.Immutable.ImmutableArray`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableArray`1.ToBuilder +System.Collections.Immutable.ImmutableArray`1.get_IsDefault +System.Collections.Immutable.ImmutableArray`1.get_IsDefaultOrEmpty +System.Collections.Immutable.ImmutableArray`1.get_IsEmpty +System.Collections.Immutable.ImmutableArray`1.get_Item(System.Int32) +System.Collections.Immutable.ImmutableArray`1.get_Length +System.Collections.Immutable.ImmutableArray`1.op_Equality(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.op_Equality(System.Nullable{System.Collections.Immutable.ImmutableArray{`0}},System.Nullable{System.Collections.Immutable.ImmutableArray{`0}}) +System.Collections.Immutable.ImmutableArray`1.op_Inequality(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Immutable.ImmutableArray{`0}) +System.Collections.Immutable.ImmutableArray`1.op_Inequality(System.Nullable{System.Collections.Immutable.ImmutableArray{`0}},System.Nullable{System.Collections.Immutable.ImmutableArray{`0}}) +System.Collections.Immutable.ImmutableDictionary +System.Collections.Immutable.ImmutableDictionary.Contains``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0,``1) +System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2 +System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2(System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableDictionary.Create``2 +System.Collections.Immutable.ImmutableDictionary.Create``2(System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableDictionary.Create``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableDictionary.GetValueOrDefault``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0) +System.Collections.Immutable.ImmutableDictionary.GetValueOrDefault``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0,``1) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}.Builder) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEqualityComparer{``2}) +System.Collections.Immutable.ImmutableDictionary`2 +System.Collections.Immutable.ImmutableDictionary`2.Add(`0,`1) +System.Collections.Immutable.ImmutableDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.ImmutableDictionary`2.Builder +System.Collections.Immutable.ImmutableDictionary`2.Builder.Add(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableDictionary`2.Builder.Add(`0,`1) +System.Collections.Immutable.ImmutableDictionary`2.Builder.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.ImmutableDictionary`2.Builder.Clear +System.Collections.Immutable.ImmutableDictionary`2.Builder.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableDictionary`2.Builder.ContainsKey(`0) +System.Collections.Immutable.ImmutableDictionary`2.Builder.ContainsValue(`1) +System.Collections.Immutable.ImmutableDictionary`2.Builder.GetEnumerator +System.Collections.Immutable.ImmutableDictionary`2.Builder.GetValueOrDefault(`0) +System.Collections.Immutable.ImmutableDictionary`2.Builder.GetValueOrDefault(`0,`1) +System.Collections.Immutable.ImmutableDictionary`2.Builder.Remove(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableDictionary`2.Builder.Remove(`0) +System.Collections.Immutable.ImmutableDictionary`2.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableDictionary`2.Builder.ToImmutable +System.Collections.Immutable.ImmutableDictionary`2.Builder.TryGetKey(`0,`0@) +System.Collections.Immutable.ImmutableDictionary`2.Builder.TryGetValue(`0,`1@) +System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Count +System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Item(`0) +System.Collections.Immutable.ImmutableDictionary`2.Builder.get_KeyComparer +System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Keys +System.Collections.Immutable.ImmutableDictionary`2.Builder.get_ValueComparer +System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Values +System.Collections.Immutable.ImmutableDictionary`2.Builder.set_Item(`0,`1) +System.Collections.Immutable.ImmutableDictionary`2.Builder.set_KeyComparer(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableDictionary`2.Builder.set_ValueComparer(System.Collections.Generic.IEqualityComparer{`1}) +System.Collections.Immutable.ImmutableDictionary`2.Clear +System.Collections.Immutable.ImmutableDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableDictionary`2.ContainsKey(`0) +System.Collections.Immutable.ImmutableDictionary`2.ContainsValue(`1) +System.Collections.Immutable.ImmutableDictionary`2.Empty +System.Collections.Immutable.ImmutableDictionary`2.Enumerator +System.Collections.Immutable.ImmutableDictionary`2.Enumerator.Dispose +System.Collections.Immutable.ImmutableDictionary`2.Enumerator.MoveNext +System.Collections.Immutable.ImmutableDictionary`2.Enumerator.Reset +System.Collections.Immutable.ImmutableDictionary`2.Enumerator.get_Current +System.Collections.Immutable.ImmutableDictionary`2.GetEnumerator +System.Collections.Immutable.ImmutableDictionary`2.Remove(`0) +System.Collections.Immutable.ImmutableDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableDictionary`2.SetItem(`0,`1) +System.Collections.Immutable.ImmutableDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.ImmutableDictionary`2.ToBuilder +System.Collections.Immutable.ImmutableDictionary`2.TryGetKey(`0,`0@) +System.Collections.Immutable.ImmutableDictionary`2.TryGetValue(`0,`1@) +System.Collections.Immutable.ImmutableDictionary`2.WithComparers(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableDictionary`2.WithComparers(System.Collections.Generic.IEqualityComparer{`0},System.Collections.Generic.IEqualityComparer{`1}) +System.Collections.Immutable.ImmutableDictionary`2.get_Count +System.Collections.Immutable.ImmutableDictionary`2.get_IsEmpty +System.Collections.Immutable.ImmutableDictionary`2.get_Item(`0) +System.Collections.Immutable.ImmutableDictionary`2.get_KeyComparer +System.Collections.Immutable.ImmutableDictionary`2.get_Keys +System.Collections.Immutable.ImmutableDictionary`2.get_ValueComparer +System.Collections.Immutable.ImmutableDictionary`2.get_Values +System.Collections.Immutable.ImmutableHashSet +System.Collections.Immutable.ImmutableHashSet.CreateBuilder``1 +System.Collections.Immutable.ImmutableHashSet.CreateBuilder``1(System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableHashSet.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableHashSet.CreateRange``1(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableHashSet.Create``1 +System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},``0) +System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},``0[]) +System.Collections.Immutable.ImmutableHashSet.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableHashSet.Create``1(``0) +System.Collections.Immutable.ImmutableHashSet.Create``1(``0[]) +System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Immutable.ImmutableHashSet{``0}.Builder) +System.Collections.Immutable.ImmutableHashSet`1 +System.Collections.Immutable.ImmutableHashSet`1.Add(`0) +System.Collections.Immutable.ImmutableHashSet`1.Builder +System.Collections.Immutable.ImmutableHashSet`1.Builder.Add(`0) +System.Collections.Immutable.ImmutableHashSet`1.Builder.Clear +System.Collections.Immutable.ImmutableHashSet`1.Builder.Contains(`0) +System.Collections.Immutable.ImmutableHashSet`1.Builder.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.GetEnumerator +System.Collections.Immutable.ImmutableHashSet`1.Builder.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.Remove(`0) +System.Collections.Immutable.ImmutableHashSet`1.Builder.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.ToImmutable +System.Collections.Immutable.ImmutableHashSet`1.Builder.TryGetValue(`0,`0@) +System.Collections.Immutable.ImmutableHashSet`1.Builder.UnionWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Builder.get_Count +System.Collections.Immutable.ImmutableHashSet`1.Builder.get_KeyComparer +System.Collections.Immutable.ImmutableHashSet`1.Builder.set_KeyComparer(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Clear +System.Collections.Immutable.ImmutableHashSet`1.Contains(`0) +System.Collections.Immutable.ImmutableHashSet`1.Empty +System.Collections.Immutable.ImmutableHashSet`1.Enumerator +System.Collections.Immutable.ImmutableHashSet`1.Enumerator.Dispose +System.Collections.Immutable.ImmutableHashSet`1.Enumerator.MoveNext +System.Collections.Immutable.ImmutableHashSet`1.Enumerator.Reset +System.Collections.Immutable.ImmutableHashSet`1.Enumerator.get_Current +System.Collections.Immutable.ImmutableHashSet`1.Except(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.GetEnumerator +System.Collections.Immutable.ImmutableHashSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.Remove(`0) +System.Collections.Immutable.ImmutableHashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.ToBuilder +System.Collections.Immutable.ImmutableHashSet`1.TryGetValue(`0,`0@) +System.Collections.Immutable.ImmutableHashSet`1.Union(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableHashSet`1.WithComparer(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableHashSet`1.get_Count +System.Collections.Immutable.ImmutableHashSet`1.get_IsEmpty +System.Collections.Immutable.ImmutableHashSet`1.get_KeyComparer +System.Collections.Immutable.ImmutableInterlocked +System.Collections.Immutable.ImmutableInterlocked.AddOrUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``1},System.Func{``0,``1,``1}) +System.Collections.Immutable.ImmutableInterlocked.AddOrUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1,System.Func{``0,``1,``1}) +System.Collections.Immutable.ImmutableInterlocked.Enqueue``1(System.Collections.Immutable.ImmutableQueue{``0}@,``0) +System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``1}) +System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1) +System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``3(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``2,``1},``2) +System.Collections.Immutable.ImmutableInterlocked.InterlockedCompareExchange``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0},System.Collections.Immutable.ImmutableArray{``0}) +System.Collections.Immutable.ImmutableInterlocked.InterlockedExchange``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0}) +System.Collections.Immutable.ImmutableInterlocked.InterlockedInitialize``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0}) +System.Collections.Immutable.ImmutableInterlocked.Push``1(System.Collections.Immutable.ImmutableStack{``0}@,``0) +System.Collections.Immutable.ImmutableInterlocked.TryAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1) +System.Collections.Immutable.ImmutableInterlocked.TryDequeue``1(System.Collections.Immutable.ImmutableQueue{``0}@,``0@) +System.Collections.Immutable.ImmutableInterlocked.TryPop``1(System.Collections.Immutable.ImmutableStack{``0}@,``0@) +System.Collections.Immutable.ImmutableInterlocked.TryRemove``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1@) +System.Collections.Immutable.ImmutableInterlocked.TryUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1,``1) +System.Collections.Immutable.ImmutableInterlocked.Update``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Func{System.Collections.Immutable.ImmutableArray{``0},System.Collections.Immutable.ImmutableArray{``0}}) +System.Collections.Immutable.ImmutableInterlocked.Update``1(``0@,System.Func{``0,``0}) +System.Collections.Immutable.ImmutableInterlocked.Update``2(System.Collections.Immutable.ImmutableArray{``0}@,System.Func{System.Collections.Immutable.ImmutableArray{``0},``1,System.Collections.Immutable.ImmutableArray{``0}},``1) +System.Collections.Immutable.ImmutableInterlocked.Update``2(``0@,System.Func{``0,``1,``0},``1) +System.Collections.Immutable.ImmutableList +System.Collections.Immutable.ImmutableList.CreateBuilder``1 +System.Collections.Immutable.ImmutableList.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableList.Create``1 +System.Collections.Immutable.ImmutableList.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableList.Create``1(``0) +System.Collections.Immutable.ImmutableList.Create``1(``0[]) +System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0) +System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32) +System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0) +System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) +System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32) +System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList.RemoveRange``1(System.Collections.Immutable.IImmutableList{``0},System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableList.Remove``1(System.Collections.Immutable.IImmutableList{``0},``0) +System.Collections.Immutable.ImmutableList.Replace``1(System.Collections.Immutable.IImmutableList{``0},``0,``0) +System.Collections.Immutable.ImmutableList.ToImmutableList``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableList.ToImmutableList``1(System.Collections.Immutable.ImmutableList{``0}.Builder) +System.Collections.Immutable.ImmutableList`1 +System.Collections.Immutable.ImmutableList`1.Add(`0) +System.Collections.Immutable.ImmutableList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableList`1.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.BinarySearch(`0) +System.Collections.Immutable.ImmutableList`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder +System.Collections.Immutable.ImmutableList`1.Builder.Add(`0) +System.Collections.Immutable.ImmutableList`1.Builder.AddRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(`0) +System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Clear +System.Collections.Immutable.ImmutableList`1.Builder.Contains(`0) +System.Collections.Immutable.ImmutableList`1.Builder.ConvertAll``1(System.Func{`0,``0}) +System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(`0[]) +System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(`0[],System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.Exists(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Find(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindLast(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.ForEach(System.Action{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.GetEnumerator +System.Collections.Immutable.ImmutableList`1.Builder.GetRange(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0) +System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Insert(System.Int32,`0) +System.Collections.Immutable.ImmutableList`1.Builder.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.ItemRef(System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0) +System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Remove(`0) +System.Collections.Immutable.ImmutableList`1.Builder.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.RemoveAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.RemoveAt(System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.Replace(`0,`0) +System.Collections.Immutable.ImmutableList`1.Builder.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Reverse +System.Collections.Immutable.ImmutableList`1.Builder.Reverse(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.Sort +System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Comparison{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.ToImmutable +System.Collections.Immutable.ImmutableList`1.Builder.TrueForAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Builder.get_Count +System.Collections.Immutable.ImmutableList`1.Builder.get_Item(System.Int32) +System.Collections.Immutable.ImmutableList`1.Builder.set_Item(System.Int32,`0) +System.Collections.Immutable.ImmutableList`1.Clear +System.Collections.Immutable.ImmutableList`1.Contains(`0) +System.Collections.Immutable.ImmutableList`1.ConvertAll``1(System.Func{`0,``0}) +System.Collections.Immutable.ImmutableList`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.CopyTo(`0[]) +System.Collections.Immutable.ImmutableList`1.CopyTo(`0[],System.Int32) +System.Collections.Immutable.ImmutableList`1.Empty +System.Collections.Immutable.ImmutableList`1.Enumerator +System.Collections.Immutable.ImmutableList`1.Enumerator.Dispose +System.Collections.Immutable.ImmutableList`1.Enumerator.MoveNext +System.Collections.Immutable.ImmutableList`1.Enumerator.Reset +System.Collections.Immutable.ImmutableList`1.Enumerator.get_Current +System.Collections.Immutable.ImmutableList`1.Exists(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.Find(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindIndex(System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindIndex(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindLast(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Int32,System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.ForEach(System.Action{`0}) +System.Collections.Immutable.ImmutableList`1.GetEnumerator +System.Collections.Immutable.ImmutableList`1.GetRange(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.IndexOf(`0) +System.Collections.Immutable.ImmutableList`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Insert(System.Int32,`0) +System.Collections.Immutable.ImmutableList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableList`1.ItemRef(System.Int32) +System.Collections.Immutable.ImmutableList`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Remove(`0) +System.Collections.Immutable.ImmutableList`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.RemoveAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.RemoveAt(System.Int32) +System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.Replace(`0,`0) +System.Collections.Immutable.ImmutableList`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Reverse +System.Collections.Immutable.ImmutableList`1.Reverse(System.Int32,System.Int32) +System.Collections.Immutable.ImmutableList`1.SetItem(System.Int32,`0) +System.Collections.Immutable.ImmutableList`1.Sort +System.Collections.Immutable.ImmutableList`1.Sort(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.Sort(System.Comparison{`0}) +System.Collections.Immutable.ImmutableList`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableList`1.ToBuilder +System.Collections.Immutable.ImmutableList`1.TrueForAll(System.Predicate{`0}) +System.Collections.Immutable.ImmutableList`1.get_Count +System.Collections.Immutable.ImmutableList`1.get_IsEmpty +System.Collections.Immutable.ImmutableList`1.get_Item(System.Int32) +System.Collections.Immutable.ImmutableQueue +System.Collections.Immutable.ImmutableQueue.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableQueue.Create``1 +System.Collections.Immutable.ImmutableQueue.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableQueue.Create``1(``0) +System.Collections.Immutable.ImmutableQueue.Create``1(``0[]) +System.Collections.Immutable.ImmutableQueue.Dequeue``1(System.Collections.Immutable.IImmutableQueue{``0},``0@) +System.Collections.Immutable.ImmutableQueue`1 +System.Collections.Immutable.ImmutableQueue`1.Clear +System.Collections.Immutable.ImmutableQueue`1.Dequeue +System.Collections.Immutable.ImmutableQueue`1.Dequeue(`0@) +System.Collections.Immutable.ImmutableQueue`1.Enqueue(`0) +System.Collections.Immutable.ImmutableQueue`1.Enumerator +System.Collections.Immutable.ImmutableQueue`1.Enumerator.MoveNext +System.Collections.Immutable.ImmutableQueue`1.Enumerator.get_Current +System.Collections.Immutable.ImmutableQueue`1.GetEnumerator +System.Collections.Immutable.ImmutableQueue`1.Peek +System.Collections.Immutable.ImmutableQueue`1.PeekRef +System.Collections.Immutable.ImmutableQueue`1.get_Empty +System.Collections.Immutable.ImmutableQueue`1.get_IsEmpty +System.Collections.Immutable.ImmutableSortedDictionary +System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2 +System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2(System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableSortedDictionary.Create``2 +System.Collections.Immutable.ImmutableSortedDictionary.Create``2(System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableSortedDictionary.Create``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Immutable.ImmutableSortedDictionary{``0,``1}.Builder) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IComparer{``1}) +System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IComparer{``1},System.Collections.Generic.IEqualityComparer{``2}) +System.Collections.Immutable.ImmutableSortedDictionary`2 +System.Collections.Immutable.ImmutableSortedDictionary`2.Add(`0,`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Add(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Add(`0,`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Clear +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ContainsKey(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ContainsValue(`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetEnumerator +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetValueOrDefault(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetValueOrDefault(`0,`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Remove(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Remove(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ToImmutable +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.TryGetKey(`0,`0@) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.TryGetValue(`0,`1@) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ValueRef(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Count +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Item(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_KeyComparer +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Keys +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_ValueComparer +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Values +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_Item(`0,`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_KeyComparer(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_ValueComparer(System.Collections.Generic.IEqualityComparer{`1}) +System.Collections.Immutable.ImmutableSortedDictionary`2.Clear +System.Collections.Immutable.ImmutableSortedDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +System.Collections.Immutable.ImmutableSortedDictionary`2.ContainsKey(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.ContainsValue(`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.Empty +System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator +System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.Dispose +System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.MoveNext +System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.Reset +System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.get_Current +System.Collections.Immutable.ImmutableSortedDictionary`2.GetEnumerator +System.Collections.Immutable.ImmutableSortedDictionary`2.Remove(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedDictionary`2.SetItem(`0,`1) +System.Collections.Immutable.ImmutableSortedDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Immutable.ImmutableSortedDictionary`2.ToBuilder +System.Collections.Immutable.ImmutableSortedDictionary`2.TryGetKey(`0,`0@) +System.Collections.Immutable.ImmutableSortedDictionary`2.TryGetValue(`0,`1@) +System.Collections.Immutable.ImmutableSortedDictionary`2.ValueRef(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.WithComparers(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableSortedDictionary`2.WithComparers(System.Collections.Generic.IComparer{`0},System.Collections.Generic.IEqualityComparer{`1}) +System.Collections.Immutable.ImmutableSortedDictionary`2.get_Count +System.Collections.Immutable.ImmutableSortedDictionary`2.get_IsEmpty +System.Collections.Immutable.ImmutableSortedDictionary`2.get_Item(`0) +System.Collections.Immutable.ImmutableSortedDictionary`2.get_KeyComparer +System.Collections.Immutable.ImmutableSortedDictionary`2.get_Keys +System.Collections.Immutable.ImmutableSortedDictionary`2.get_ValueComparer +System.Collections.Immutable.ImmutableSortedDictionary`2.get_Values +System.Collections.Immutable.ImmutableSortedSet +System.Collections.Immutable.ImmutableSortedSet.CreateBuilder``1 +System.Collections.Immutable.ImmutableSortedSet.CreateBuilder``1(System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableSortedSet.CreateRange``1(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableSortedSet.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableSortedSet.Create``1 +System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},``0) +System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},``0[]) +System.Collections.Immutable.ImmutableSortedSet.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableSortedSet.Create``1(``0) +System.Collections.Immutable.ImmutableSortedSet.Create``1(``0[]) +System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Immutable.ImmutableSortedSet{``0}.Builder) +System.Collections.Immutable.ImmutableSortedSet`1 +System.Collections.Immutable.ImmutableSortedSet`1.Add(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Builder +System.Collections.Immutable.ImmutableSortedSet`1.Builder.Add(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.Clear +System.Collections.Immutable.ImmutableSortedSet`1.Builder.Contains(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.GetEnumerator +System.Collections.Immutable.ImmutableSortedSet`1.Builder.IndexOf(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.ItemRef(System.Int32) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.Remove(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.Reverse +System.Collections.Immutable.ImmutableSortedSet`1.Builder.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.ToImmutable +System.Collections.Immutable.ImmutableSortedSet`1.Builder.TryGetValue(`0,`0@) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.UnionWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Count +System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Item(System.Int32) +System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_KeyComparer +System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Max +System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Min +System.Collections.Immutable.ImmutableSortedSet`1.Builder.set_KeyComparer(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Clear +System.Collections.Immutable.ImmutableSortedSet`1.Contains(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Empty +System.Collections.Immutable.ImmutableSortedSet`1.Enumerator +System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.Dispose +System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.MoveNext +System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.Reset +System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.get_Current +System.Collections.Immutable.ImmutableSortedSet`1.Except(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.GetEnumerator +System.Collections.Immutable.ImmutableSortedSet`1.IndexOf(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.ItemRef(System.Int32) +System.Collections.Immutable.ImmutableSortedSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.Remove(`0) +System.Collections.Immutable.ImmutableSortedSet`1.Reverse +System.Collections.Immutable.ImmutableSortedSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.ToBuilder +System.Collections.Immutable.ImmutableSortedSet`1.TryGetValue(`0,`0@) +System.Collections.Immutable.ImmutableSortedSet`1.Union(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.WithComparer(System.Collections.Generic.IComparer{`0}) +System.Collections.Immutable.ImmutableSortedSet`1.get_Count +System.Collections.Immutable.ImmutableSortedSet`1.get_IsEmpty +System.Collections.Immutable.ImmutableSortedSet`1.get_Item(System.Int32) +System.Collections.Immutable.ImmutableSortedSet`1.get_KeyComparer +System.Collections.Immutable.ImmutableSortedSet`1.get_Max +System.Collections.Immutable.ImmutableSortedSet`1.get_Min +System.Collections.Immutable.ImmutableStack +System.Collections.Immutable.ImmutableStack.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +System.Collections.Immutable.ImmutableStack.Create``1 +System.Collections.Immutable.ImmutableStack.Create``1(System.ReadOnlySpan{``0}) +System.Collections.Immutable.ImmutableStack.Create``1(``0) +System.Collections.Immutable.ImmutableStack.Create``1(``0[]) +System.Collections.Immutable.ImmutableStack.Pop``1(System.Collections.Immutable.IImmutableStack{``0},``0@) +System.Collections.Immutable.ImmutableStack`1 +System.Collections.Immutable.ImmutableStack`1.Clear +System.Collections.Immutable.ImmutableStack`1.Enumerator +System.Collections.Immutable.ImmutableStack`1.Enumerator.MoveNext +System.Collections.Immutable.ImmutableStack`1.Enumerator.get_Current +System.Collections.Immutable.ImmutableStack`1.GetEnumerator +System.Collections.Immutable.ImmutableStack`1.Peek +System.Collections.Immutable.ImmutableStack`1.PeekRef +System.Collections.Immutable.ImmutableStack`1.Pop +System.Collections.Immutable.ImmutableStack`1.Pop(`0@) +System.Collections.Immutable.ImmutableStack`1.Push(`0) +System.Collections.Immutable.ImmutableStack`1.get_Empty +System.Collections.Immutable.ImmutableStack`1.get_IsEmpty +System.Linq.ImmutableArrayExtensions +System.Linq.ImmutableArrayExtensions.Aggregate``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``0,``0}) +System.Linq.ImmutableArrayExtensions.Aggregate``2(System.Collections.Immutable.ImmutableArray{``1},``0,System.Func{``0,``1,``0}) +System.Linq.ImmutableArrayExtensions.Aggregate``3(System.Collections.Immutable.ImmutableArray{``2},``0,System.Func{``0,``2,``0},System.Func{``0,``1}) +System.Linq.ImmutableArrayExtensions.All``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Linq.ImmutableArrayExtensions.ElementAtOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32) +System.Linq.ImmutableArrayExtensions.ElementAt``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32) +System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +System.Linq.ImmutableArrayExtensions.SelectMany``3(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) +System.Linq.ImmutableArrayExtensions.Select``2(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1}) +System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Immutable.ImmutableArray{``0},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Immutable.ImmutableArray{``0},System.Func{``1,``1,System.Boolean}) +System.Linq.ImmutableArrayExtensions.SingleOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.SingleOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.Single``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.Single``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Linq.ImmutableArrayExtensions.ToArray``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Linq.ImmutableArrayExtensions.ToDictionary``2(System.Collections.Immutable.ImmutableArray{``1},System.Func{``1,``0}) +System.Linq.ImmutableArrayExtensions.ToDictionary``2(System.Collections.Immutable.ImmutableArray{``1},System.Func{``1,``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.ImmutableArrayExtensions.ToDictionary``3(System.Collections.Immutable.ImmutableArray{``2},System.Func{``2,``0},System.Func{``2,``1}) +System.Linq.ImmutableArrayExtensions.ToDictionary``3(System.Collections.Immutable.ImmutableArray{``2},System.Func{``2,``0},System.Func{``2,``1},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.ImmutableArrayExtensions.Where``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +System.Runtime.InteropServices.ImmutableCollectionsMarshal +System.Runtime.InteropServices.ImmutableCollectionsMarshal.AsArray``1(System.Collections.Immutable.ImmutableArray{``0}) +System.Runtime.InteropServices.ImmutableCollectionsMarshal.AsImmutableArray``1(``0[]) \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt new file mode 100644 index 0000000000000..3caa7122e372a --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt @@ -0,0 +1,525 @@ +# Generated, do not update manually +System.Collections.BitArray +System.Collections.BitArray.#ctor(System.Boolean[]) +System.Collections.BitArray.#ctor(System.Byte[]) +System.Collections.BitArray.#ctor(System.Collections.BitArray) +System.Collections.BitArray.#ctor(System.Int32) +System.Collections.BitArray.#ctor(System.Int32,System.Boolean) +System.Collections.BitArray.#ctor(System.Int32[]) +System.Collections.BitArray.And(System.Collections.BitArray) +System.Collections.BitArray.Clone +System.Collections.BitArray.CopyTo(System.Array,System.Int32) +System.Collections.BitArray.Get(System.Int32) +System.Collections.BitArray.GetEnumerator +System.Collections.BitArray.HasAllSet +System.Collections.BitArray.HasAnySet +System.Collections.BitArray.LeftShift(System.Int32) +System.Collections.BitArray.Not +System.Collections.BitArray.Or(System.Collections.BitArray) +System.Collections.BitArray.RightShift(System.Int32) +System.Collections.BitArray.Set(System.Int32,System.Boolean) +System.Collections.BitArray.SetAll(System.Boolean) +System.Collections.BitArray.Xor(System.Collections.BitArray) +System.Collections.BitArray.get_Count +System.Collections.BitArray.get_IsReadOnly +System.Collections.BitArray.get_IsSynchronized +System.Collections.BitArray.get_Item(System.Int32) +System.Collections.BitArray.get_Length +System.Collections.BitArray.get_SyncRoot +System.Collections.BitArray.set_Item(System.Int32,System.Boolean) +System.Collections.BitArray.set_Length(System.Int32) +System.Collections.Generic.CollectionExtensions +System.Collections.Generic.CollectionExtensions.AddRange``1(System.Collections.Generic.List{``0},System.ReadOnlySpan{``0}) +System.Collections.Generic.CollectionExtensions.AsReadOnly``1(System.Collections.Generic.IList{``0}) +System.Collections.Generic.CollectionExtensions.AsReadOnly``2(System.Collections.Generic.IDictionary{``0,``1}) +System.Collections.Generic.CollectionExtensions.CopyTo``1(System.Collections.Generic.List{``0},System.Span{``0}) +System.Collections.Generic.CollectionExtensions.GetValueOrDefault``2(System.Collections.Generic.IReadOnlyDictionary{``0,``1},``0) +System.Collections.Generic.CollectionExtensions.GetValueOrDefault``2(System.Collections.Generic.IReadOnlyDictionary{``0,``1},``0,``1) +System.Collections.Generic.CollectionExtensions.InsertRange``1(System.Collections.Generic.List{``0},System.Int32,System.ReadOnlySpan{``0}) +System.Collections.Generic.CollectionExtensions.Remove``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1@) +System.Collections.Generic.CollectionExtensions.TryAdd``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1) +System.Collections.Generic.Comparer`1 +System.Collections.Generic.Comparer`1.#ctor +System.Collections.Generic.Comparer`1.Compare(`0,`0) +System.Collections.Generic.Comparer`1.Create(System.Comparison{`0}) +System.Collections.Generic.Comparer`1.get_Default +System.Collections.Generic.Dictionary`2 +System.Collections.Generic.Dictionary`2.#ctor +System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.Dictionary`2.#ctor(System.Int32) +System.Collections.Generic.Dictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.Dictionary`2.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.Dictionary`2.Add(`0,`1) +System.Collections.Generic.Dictionary`2.AlternateLookup`1 +System.Collections.Generic.Dictionary`2.AlternateLookup`1.ContainsKey(`2) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.Remove(`2) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.Remove(`2,`0@,`1@) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.TryAdd(`2,`1) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.TryGetValue(`2,`0@,`1@) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.TryGetValue(`2,`1@) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.get_Dictionary +System.Collections.Generic.Dictionary`2.AlternateLookup`1.get_Item(`2) +System.Collections.Generic.Dictionary`2.AlternateLookup`1.set_Item(`2,`1) +System.Collections.Generic.Dictionary`2.Clear +System.Collections.Generic.Dictionary`2.ContainsKey(`0) +System.Collections.Generic.Dictionary`2.ContainsValue(`1) +System.Collections.Generic.Dictionary`2.EnsureCapacity(System.Int32) +System.Collections.Generic.Dictionary`2.Enumerator +System.Collections.Generic.Dictionary`2.Enumerator.Dispose +System.Collections.Generic.Dictionary`2.Enumerator.MoveNext +System.Collections.Generic.Dictionary`2.Enumerator.get_Current +System.Collections.Generic.Dictionary`2.GetAlternateLookup``1 +System.Collections.Generic.Dictionary`2.GetEnumerator +System.Collections.Generic.Dictionary`2.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.Dictionary`2.KeyCollection +System.Collections.Generic.Dictionary`2.KeyCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) +System.Collections.Generic.Dictionary`2.KeyCollection.Contains(`0) +System.Collections.Generic.Dictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator +System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.Dispose +System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.MoveNext +System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.get_Current +System.Collections.Generic.Dictionary`2.KeyCollection.GetEnumerator +System.Collections.Generic.Dictionary`2.KeyCollection.get_Count +System.Collections.Generic.Dictionary`2.OnDeserialization(System.Object) +System.Collections.Generic.Dictionary`2.Remove(`0) +System.Collections.Generic.Dictionary`2.Remove(`0,`1@) +System.Collections.Generic.Dictionary`2.TrimExcess +System.Collections.Generic.Dictionary`2.TrimExcess(System.Int32) +System.Collections.Generic.Dictionary`2.TryAdd(`0,`1) +System.Collections.Generic.Dictionary`2.TryGetAlternateLookup``1(System.Collections.Generic.Dictionary{`0,`1}.AlternateLookup{``0}@) +System.Collections.Generic.Dictionary`2.TryGetValue(`0,`1@) +System.Collections.Generic.Dictionary`2.ValueCollection +System.Collections.Generic.Dictionary`2.ValueCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) +System.Collections.Generic.Dictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator +System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.Dispose +System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.MoveNext +System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.get_Current +System.Collections.Generic.Dictionary`2.ValueCollection.GetEnumerator +System.Collections.Generic.Dictionary`2.ValueCollection.get_Count +System.Collections.Generic.Dictionary`2.get_Capacity +System.Collections.Generic.Dictionary`2.get_Comparer +System.Collections.Generic.Dictionary`2.get_Count +System.Collections.Generic.Dictionary`2.get_Item(`0) +System.Collections.Generic.Dictionary`2.get_Keys +System.Collections.Generic.Dictionary`2.get_Values +System.Collections.Generic.Dictionary`2.set_Item(`0,`1) +System.Collections.Generic.EqualityComparer`1 +System.Collections.Generic.EqualityComparer`1.#ctor +System.Collections.Generic.EqualityComparer`1.Create(System.Func{`0,`0,System.Boolean},System.Func{`0,System.Int32}) +System.Collections.Generic.EqualityComparer`1.Equals(`0,`0) +System.Collections.Generic.EqualityComparer`1.GetHashCode(`0) +System.Collections.Generic.EqualityComparer`1.get_Default +System.Collections.Generic.HashSet`1 +System.Collections.Generic.HashSet`1.#ctor +System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.HashSet`1.#ctor(System.Int32) +System.Collections.Generic.HashSet`1.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.HashSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.HashSet`1.Add(`0) +System.Collections.Generic.HashSet`1.AlternateLookup`1 +System.Collections.Generic.HashSet`1.AlternateLookup`1.Add(`1) +System.Collections.Generic.HashSet`1.AlternateLookup`1.Contains(`1) +System.Collections.Generic.HashSet`1.AlternateLookup`1.Remove(`1) +System.Collections.Generic.HashSet`1.AlternateLookup`1.TryGetValue(`1,`0@) +System.Collections.Generic.HashSet`1.AlternateLookup`1.get_Set +System.Collections.Generic.HashSet`1.Clear +System.Collections.Generic.HashSet`1.Contains(`0) +System.Collections.Generic.HashSet`1.CopyTo(`0[]) +System.Collections.Generic.HashSet`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.HashSet`1.CopyTo(`0[],System.Int32,System.Int32) +System.Collections.Generic.HashSet`1.CreateSetComparer +System.Collections.Generic.HashSet`1.EnsureCapacity(System.Int32) +System.Collections.Generic.HashSet`1.Enumerator +System.Collections.Generic.HashSet`1.Enumerator.Dispose +System.Collections.Generic.HashSet`1.Enumerator.MoveNext +System.Collections.Generic.HashSet`1.Enumerator.get_Current +System.Collections.Generic.HashSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.GetAlternateLookup``1 +System.Collections.Generic.HashSet`1.GetEnumerator +System.Collections.Generic.HashSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.HashSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.OnDeserialization(System.Object) +System.Collections.Generic.HashSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.Remove(`0) +System.Collections.Generic.HashSet`1.RemoveWhere(System.Predicate{`0}) +System.Collections.Generic.HashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.TrimExcess +System.Collections.Generic.HashSet`1.TrimExcess(System.Int32) +System.Collections.Generic.HashSet`1.TryGetAlternateLookup``1(System.Collections.Generic.HashSet{`0}.AlternateLookup{``0}@) +System.Collections.Generic.HashSet`1.TryGetValue(`0,`0@) +System.Collections.Generic.HashSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.HashSet`1.get_Capacity +System.Collections.Generic.HashSet`1.get_Comparer +System.Collections.Generic.HashSet`1.get_Count +System.Collections.Generic.LinkedListNode`1 +System.Collections.Generic.LinkedListNode`1.#ctor(`0) +System.Collections.Generic.LinkedListNode`1.get_List +System.Collections.Generic.LinkedListNode`1.get_Next +System.Collections.Generic.LinkedListNode`1.get_Previous +System.Collections.Generic.LinkedListNode`1.get_Value +System.Collections.Generic.LinkedListNode`1.get_ValueRef +System.Collections.Generic.LinkedListNode`1.set_Value(`0) +System.Collections.Generic.LinkedList`1 +System.Collections.Generic.LinkedList`1.#ctor +System.Collections.Generic.LinkedList`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.LinkedList`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.LinkedList`1.AddAfter(System.Collections.Generic.LinkedListNode{`0},System.Collections.Generic.LinkedListNode{`0}) +System.Collections.Generic.LinkedList`1.AddAfter(System.Collections.Generic.LinkedListNode{`0},`0) +System.Collections.Generic.LinkedList`1.AddBefore(System.Collections.Generic.LinkedListNode{`0},System.Collections.Generic.LinkedListNode{`0}) +System.Collections.Generic.LinkedList`1.AddBefore(System.Collections.Generic.LinkedListNode{`0},`0) +System.Collections.Generic.LinkedList`1.AddFirst(System.Collections.Generic.LinkedListNode{`0}) +System.Collections.Generic.LinkedList`1.AddFirst(`0) +System.Collections.Generic.LinkedList`1.AddLast(System.Collections.Generic.LinkedListNode{`0}) +System.Collections.Generic.LinkedList`1.AddLast(`0) +System.Collections.Generic.LinkedList`1.Clear +System.Collections.Generic.LinkedList`1.Contains(`0) +System.Collections.Generic.LinkedList`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.LinkedList`1.Enumerator +System.Collections.Generic.LinkedList`1.Enumerator.Dispose +System.Collections.Generic.LinkedList`1.Enumerator.MoveNext +System.Collections.Generic.LinkedList`1.Enumerator.get_Current +System.Collections.Generic.LinkedList`1.Find(`0) +System.Collections.Generic.LinkedList`1.FindLast(`0) +System.Collections.Generic.LinkedList`1.GetEnumerator +System.Collections.Generic.LinkedList`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.LinkedList`1.OnDeserialization(System.Object) +System.Collections.Generic.LinkedList`1.Remove(System.Collections.Generic.LinkedListNode{`0}) +System.Collections.Generic.LinkedList`1.Remove(`0) +System.Collections.Generic.LinkedList`1.RemoveFirst +System.Collections.Generic.LinkedList`1.RemoveLast +System.Collections.Generic.LinkedList`1.get_Count +System.Collections.Generic.LinkedList`1.get_First +System.Collections.Generic.LinkedList`1.get_Last +System.Collections.Generic.List`1 +System.Collections.Generic.List`1.#ctor +System.Collections.Generic.List`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.List`1.#ctor(System.Int32) +System.Collections.Generic.List`1.Add(`0) +System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.List`1.AsReadOnly +System.Collections.Generic.List`1.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.List`1.BinarySearch(`0) +System.Collections.Generic.List`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.List`1.Clear +System.Collections.Generic.List`1.Contains(`0) +System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0}) +System.Collections.Generic.List`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +System.Collections.Generic.List`1.CopyTo(`0[]) +System.Collections.Generic.List`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.List`1.EnsureCapacity(System.Int32) +System.Collections.Generic.List`1.Enumerator +System.Collections.Generic.List`1.Enumerator.Dispose +System.Collections.Generic.List`1.Enumerator.MoveNext +System.Collections.Generic.List`1.Enumerator.get_Current +System.Collections.Generic.List`1.Exists(System.Predicate{`0}) +System.Collections.Generic.List`1.Find(System.Predicate{`0}) +System.Collections.Generic.List`1.FindAll(System.Predicate{`0}) +System.Collections.Generic.List`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) +System.Collections.Generic.List`1.FindIndex(System.Int32,System.Predicate{`0}) +System.Collections.Generic.List`1.FindIndex(System.Predicate{`0}) +System.Collections.Generic.List`1.FindLast(System.Predicate{`0}) +System.Collections.Generic.List`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) +System.Collections.Generic.List`1.FindLastIndex(System.Int32,System.Predicate{`0}) +System.Collections.Generic.List`1.FindLastIndex(System.Predicate{`0}) +System.Collections.Generic.List`1.ForEach(System.Action{`0}) +System.Collections.Generic.List`1.GetEnumerator +System.Collections.Generic.List`1.GetRange(System.Int32,System.Int32) +System.Collections.Generic.List`1.IndexOf(`0) +System.Collections.Generic.List`1.IndexOf(`0,System.Int32) +System.Collections.Generic.List`1.IndexOf(`0,System.Int32,System.Int32) +System.Collections.Generic.List`1.Insert(System.Int32,`0) +System.Collections.Generic.List`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.List`1.LastIndexOf(`0) +System.Collections.Generic.List`1.LastIndexOf(`0,System.Int32) +System.Collections.Generic.List`1.LastIndexOf(`0,System.Int32,System.Int32) +System.Collections.Generic.List`1.Remove(`0) +System.Collections.Generic.List`1.RemoveAll(System.Predicate{`0}) +System.Collections.Generic.List`1.RemoveAt(System.Int32) +System.Collections.Generic.List`1.RemoveRange(System.Int32,System.Int32) +System.Collections.Generic.List`1.Reverse +System.Collections.Generic.List`1.Reverse(System.Int32,System.Int32) +System.Collections.Generic.List`1.Slice(System.Int32,System.Int32) +System.Collections.Generic.List`1.Sort +System.Collections.Generic.List`1.Sort(System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.List`1.Sort(System.Comparison{`0}) +System.Collections.Generic.List`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.List`1.ToArray +System.Collections.Generic.List`1.TrimExcess +System.Collections.Generic.List`1.TrueForAll(System.Predicate{`0}) +System.Collections.Generic.List`1.get_Capacity +System.Collections.Generic.List`1.get_Count +System.Collections.Generic.List`1.get_Item(System.Int32) +System.Collections.Generic.List`1.set_Capacity(System.Int32) +System.Collections.Generic.List`1.set_Item(System.Int32,`0) +System.Collections.Generic.OrderedDictionary`2 +System.Collections.Generic.OrderedDictionary`2.#ctor +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Int32) +System.Collections.Generic.OrderedDictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.OrderedDictionary`2.Add(`0,`1) +System.Collections.Generic.OrderedDictionary`2.Clear +System.Collections.Generic.OrderedDictionary`2.ContainsKey(`0) +System.Collections.Generic.OrderedDictionary`2.ContainsValue(`1) +System.Collections.Generic.OrderedDictionary`2.EnsureCapacity(System.Int32) +System.Collections.Generic.OrderedDictionary`2.Enumerator +System.Collections.Generic.OrderedDictionary`2.Enumerator.MoveNext +System.Collections.Generic.OrderedDictionary`2.Enumerator.get_Current +System.Collections.Generic.OrderedDictionary`2.GetAt(System.Int32) +System.Collections.Generic.OrderedDictionary`2.GetEnumerator +System.Collections.Generic.OrderedDictionary`2.IndexOf(`0) +System.Collections.Generic.OrderedDictionary`2.Insert(System.Int32,`0,`1) +System.Collections.Generic.OrderedDictionary`2.KeyCollection +System.Collections.Generic.OrderedDictionary`2.KeyCollection.Contains(`0) +System.Collections.Generic.OrderedDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +System.Collections.Generic.OrderedDictionary`2.KeyCollection.Enumerator +System.Collections.Generic.OrderedDictionary`2.KeyCollection.Enumerator.MoveNext +System.Collections.Generic.OrderedDictionary`2.KeyCollection.Enumerator.get_Current +System.Collections.Generic.OrderedDictionary`2.KeyCollection.GetEnumerator +System.Collections.Generic.OrderedDictionary`2.KeyCollection.get_Count +System.Collections.Generic.OrderedDictionary`2.Remove(`0) +System.Collections.Generic.OrderedDictionary`2.Remove(`0,`1@) +System.Collections.Generic.OrderedDictionary`2.RemoveAt(System.Int32) +System.Collections.Generic.OrderedDictionary`2.SetAt(System.Int32,`0,`1) +System.Collections.Generic.OrderedDictionary`2.SetAt(System.Int32,`1) +System.Collections.Generic.OrderedDictionary`2.TrimExcess +System.Collections.Generic.OrderedDictionary`2.TrimExcess(System.Int32) +System.Collections.Generic.OrderedDictionary`2.TryAdd(`0,`1) +System.Collections.Generic.OrderedDictionary`2.TryGetValue(`0,`1@) +System.Collections.Generic.OrderedDictionary`2.ValueCollection +System.Collections.Generic.OrderedDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +System.Collections.Generic.OrderedDictionary`2.ValueCollection.Enumerator +System.Collections.Generic.OrderedDictionary`2.ValueCollection.Enumerator.MoveNext +System.Collections.Generic.OrderedDictionary`2.ValueCollection.Enumerator.get_Current +System.Collections.Generic.OrderedDictionary`2.ValueCollection.GetEnumerator +System.Collections.Generic.OrderedDictionary`2.ValueCollection.get_Count +System.Collections.Generic.OrderedDictionary`2.get_Capacity +System.Collections.Generic.OrderedDictionary`2.get_Comparer +System.Collections.Generic.OrderedDictionary`2.get_Count +System.Collections.Generic.OrderedDictionary`2.get_Item(`0) +System.Collections.Generic.OrderedDictionary`2.get_Keys +System.Collections.Generic.OrderedDictionary`2.get_Values +System.Collections.Generic.OrderedDictionary`2.set_Item(`0,`1) +System.Collections.Generic.PriorityQueue`2 +System.Collections.Generic.PriorityQueue`2.#ctor +System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IComparer{`1}) +System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}}) +System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}},System.Collections.Generic.IComparer{`1}) +System.Collections.Generic.PriorityQueue`2.#ctor(System.Int32) +System.Collections.Generic.PriorityQueue`2.#ctor(System.Int32,System.Collections.Generic.IComparer{`1}) +System.Collections.Generic.PriorityQueue`2.Clear +System.Collections.Generic.PriorityQueue`2.Dequeue +System.Collections.Generic.PriorityQueue`2.DequeueEnqueue(`0,`1) +System.Collections.Generic.PriorityQueue`2.Enqueue(`0,`1) +System.Collections.Generic.PriorityQueue`2.EnqueueDequeue(`0,`1) +System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}}) +System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{`0},`1) +System.Collections.Generic.PriorityQueue`2.EnsureCapacity(System.Int32) +System.Collections.Generic.PriorityQueue`2.Peek +System.Collections.Generic.PriorityQueue`2.Remove(`0,`0@,`1@,System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.PriorityQueue`2.TrimExcess +System.Collections.Generic.PriorityQueue`2.TryDequeue(`0@,`1@) +System.Collections.Generic.PriorityQueue`2.TryPeek(`0@,`1@) +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.Dispose +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.MoveNext +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.get_Current +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.GetEnumerator +System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.get_Count +System.Collections.Generic.PriorityQueue`2.get_Comparer +System.Collections.Generic.PriorityQueue`2.get_Count +System.Collections.Generic.PriorityQueue`2.get_UnorderedItems +System.Collections.Generic.Queue`1 +System.Collections.Generic.Queue`1.#ctor +System.Collections.Generic.Queue`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.Queue`1.#ctor(System.Int32) +System.Collections.Generic.Queue`1.Clear +System.Collections.Generic.Queue`1.Contains(`0) +System.Collections.Generic.Queue`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.Queue`1.Dequeue +System.Collections.Generic.Queue`1.Enqueue(`0) +System.Collections.Generic.Queue`1.EnsureCapacity(System.Int32) +System.Collections.Generic.Queue`1.Enumerator +System.Collections.Generic.Queue`1.Enumerator.Dispose +System.Collections.Generic.Queue`1.Enumerator.MoveNext +System.Collections.Generic.Queue`1.Enumerator.get_Current +System.Collections.Generic.Queue`1.GetEnumerator +System.Collections.Generic.Queue`1.Peek +System.Collections.Generic.Queue`1.ToArray +System.Collections.Generic.Queue`1.TrimExcess +System.Collections.Generic.Queue`1.TrimExcess(System.Int32) +System.Collections.Generic.Queue`1.TryDequeue(`0@) +System.Collections.Generic.Queue`1.TryPeek(`0@) +System.Collections.Generic.Queue`1.get_Capacity +System.Collections.Generic.Queue`1.get_Count +System.Collections.Generic.ReferenceEqualityComparer +System.Collections.Generic.ReferenceEqualityComparer.Equals(System.Object,System.Object) +System.Collections.Generic.ReferenceEqualityComparer.GetHashCode(System.Object) +System.Collections.Generic.ReferenceEqualityComparer.get_Instance +System.Collections.Generic.SortedDictionary`2 +System.Collections.Generic.SortedDictionary`2.#ctor +System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedDictionary`2.Add(`0,`1) +System.Collections.Generic.SortedDictionary`2.Clear +System.Collections.Generic.SortedDictionary`2.ContainsKey(`0) +System.Collections.Generic.SortedDictionary`2.ContainsValue(`1) +System.Collections.Generic.SortedDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) +System.Collections.Generic.SortedDictionary`2.Enumerator +System.Collections.Generic.SortedDictionary`2.Enumerator.Dispose +System.Collections.Generic.SortedDictionary`2.Enumerator.MoveNext +System.Collections.Generic.SortedDictionary`2.Enumerator.get_Current +System.Collections.Generic.SortedDictionary`2.GetEnumerator +System.Collections.Generic.SortedDictionary`2.KeyCollection +System.Collections.Generic.SortedDictionary`2.KeyCollection.#ctor(System.Collections.Generic.SortedDictionary{`0,`1}) +System.Collections.Generic.SortedDictionary`2.KeyCollection.Contains(`0) +System.Collections.Generic.SortedDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator +System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.Dispose +System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.MoveNext +System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.get_Current +System.Collections.Generic.SortedDictionary`2.KeyCollection.GetEnumerator +System.Collections.Generic.SortedDictionary`2.KeyCollection.get_Count +System.Collections.Generic.SortedDictionary`2.Remove(`0) +System.Collections.Generic.SortedDictionary`2.TryGetValue(`0,`1@) +System.Collections.Generic.SortedDictionary`2.ValueCollection +System.Collections.Generic.SortedDictionary`2.ValueCollection.#ctor(System.Collections.Generic.SortedDictionary{`0,`1}) +System.Collections.Generic.SortedDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator +System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.Dispose +System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.MoveNext +System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.get_Current +System.Collections.Generic.SortedDictionary`2.ValueCollection.GetEnumerator +System.Collections.Generic.SortedDictionary`2.ValueCollection.get_Count +System.Collections.Generic.SortedDictionary`2.get_Comparer +System.Collections.Generic.SortedDictionary`2.get_Count +System.Collections.Generic.SortedDictionary`2.get_Item(`0) +System.Collections.Generic.SortedDictionary`2.get_Keys +System.Collections.Generic.SortedDictionary`2.get_Values +System.Collections.Generic.SortedDictionary`2.set_Item(`0,`1) +System.Collections.Generic.SortedList`2 +System.Collections.Generic.SortedList`2.#ctor +System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedList`2.#ctor(System.Int32) +System.Collections.Generic.SortedList`2.#ctor(System.Int32,System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedList`2.Add(`0,`1) +System.Collections.Generic.SortedList`2.Clear +System.Collections.Generic.SortedList`2.ContainsKey(`0) +System.Collections.Generic.SortedList`2.ContainsValue(`1) +System.Collections.Generic.SortedList`2.GetEnumerator +System.Collections.Generic.SortedList`2.GetKeyAtIndex(System.Int32) +System.Collections.Generic.SortedList`2.GetValueAtIndex(System.Int32) +System.Collections.Generic.SortedList`2.IndexOfKey(`0) +System.Collections.Generic.SortedList`2.IndexOfValue(`1) +System.Collections.Generic.SortedList`2.Remove(`0) +System.Collections.Generic.SortedList`2.RemoveAt(System.Int32) +System.Collections.Generic.SortedList`2.SetValueAtIndex(System.Int32,`1) +System.Collections.Generic.SortedList`2.TrimExcess +System.Collections.Generic.SortedList`2.TryGetValue(`0,`1@) +System.Collections.Generic.SortedList`2.get_Capacity +System.Collections.Generic.SortedList`2.get_Comparer +System.Collections.Generic.SortedList`2.get_Count +System.Collections.Generic.SortedList`2.get_Item(`0) +System.Collections.Generic.SortedList`2.get_Keys +System.Collections.Generic.SortedList`2.get_Values +System.Collections.Generic.SortedList`2.set_Capacity(System.Int32) +System.Collections.Generic.SortedList`2.set_Item(`0,`1) +System.Collections.Generic.SortedSet`1 +System.Collections.Generic.SortedSet`1.#ctor +System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IComparer{`0}) +System.Collections.Generic.SortedSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.SortedSet`1.Add(`0) +System.Collections.Generic.SortedSet`1.Clear +System.Collections.Generic.SortedSet`1.Contains(`0) +System.Collections.Generic.SortedSet`1.CopyTo(`0[]) +System.Collections.Generic.SortedSet`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.SortedSet`1.CopyTo(`0[],System.Int32,System.Int32) +System.Collections.Generic.SortedSet`1.CreateSetComparer +System.Collections.Generic.SortedSet`1.CreateSetComparer(System.Collections.Generic.IEqualityComparer{`0}) +System.Collections.Generic.SortedSet`1.Enumerator +System.Collections.Generic.SortedSet`1.Enumerator.Dispose +System.Collections.Generic.SortedSet`1.Enumerator.MoveNext +System.Collections.Generic.SortedSet`1.Enumerator.get_Current +System.Collections.Generic.SortedSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.GetEnumerator +System.Collections.Generic.SortedSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.SortedSet`1.GetViewBetween(`0,`0) +System.Collections.Generic.SortedSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.OnDeserialization(System.Object) +System.Collections.Generic.SortedSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.Remove(`0) +System.Collections.Generic.SortedSet`1.RemoveWhere(System.Predicate{`0}) +System.Collections.Generic.SortedSet`1.Reverse +System.Collections.Generic.SortedSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.TryGetValue(`0,`0@) +System.Collections.Generic.SortedSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.SortedSet`1.get_Comparer +System.Collections.Generic.SortedSet`1.get_Count +System.Collections.Generic.SortedSet`1.get_Max +System.Collections.Generic.SortedSet`1.get_Min +System.Collections.Generic.Stack`1 +System.Collections.Generic.Stack`1.#ctor +System.Collections.Generic.Stack`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.Stack`1.#ctor(System.Int32) +System.Collections.Generic.Stack`1.Clear +System.Collections.Generic.Stack`1.Contains(`0) +System.Collections.Generic.Stack`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.Stack`1.EnsureCapacity(System.Int32) +System.Collections.Generic.Stack`1.Enumerator +System.Collections.Generic.Stack`1.Enumerator.Dispose +System.Collections.Generic.Stack`1.Enumerator.MoveNext +System.Collections.Generic.Stack`1.Enumerator.get_Current +System.Collections.Generic.Stack`1.GetEnumerator +System.Collections.Generic.Stack`1.Peek +System.Collections.Generic.Stack`1.Pop +System.Collections.Generic.Stack`1.Push(`0) +System.Collections.Generic.Stack`1.ToArray +System.Collections.Generic.Stack`1.TrimExcess +System.Collections.Generic.Stack`1.TrimExcess(System.Int32) +System.Collections.Generic.Stack`1.TryPeek(`0@) +System.Collections.Generic.Stack`1.TryPop(`0@) +System.Collections.Generic.Stack`1.get_Capacity +System.Collections.Generic.Stack`1.get_Count +System.Collections.ObjectModel.ReadOnlySet`1 +System.Collections.ObjectModel.ReadOnlySet`1.#ctor(System.Collections.Generic.ISet{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.Contains(`0) +System.Collections.ObjectModel.ReadOnlySet`1.GetEnumerator +System.Collections.ObjectModel.ReadOnlySet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.ObjectModel.ReadOnlySet`1.get_Count +System.Collections.ObjectModel.ReadOnlySet`1.get_Empty +System.Collections.ObjectModel.ReadOnlySet`1.get_Set +System.Collections.StructuralComparisons +System.Collections.StructuralComparisons.get_StructuralComparer +System.Collections.StructuralComparisons.get_StructuralEqualityComparer \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt new file mode 100644 index 0000000000000..dea122b02f26e --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt @@ -0,0 +1,236 @@ +# Generated, do not update manually +System.Linq.Enumerable +System.Linq.Enumerable.AggregateBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.AggregateBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},``2,System.Func{``2,``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0}) +System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1}) +System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2}) +System.Linq.Enumerable.All``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.AsEnumerable``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Decimal}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Double}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Int32}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Int64}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Single}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +System.Linq.Enumerable.Cast``1(System.Collections.IEnumerable) +System.Linq.Enumerable.Chunk``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.Distinct``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Distinct``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.ElementAtOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Index) +System.Linq.Enumerable.ElementAtOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.ElementAt``1(System.Collections.Generic.IEnumerable{``0},System.Index) +System.Linq.Enumerable.ElementAt``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.Empty``1 +System.Linq.Enumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) +System.Linq.Enumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.Except``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Except``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) +System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.First``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.First``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.GroupBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.GroupBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2}) +System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3}) +System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3}) +System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2}) +System.Linq.Enumerable.Index``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) +System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3}) +System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2}) +System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) +System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.Last``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Last``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.LongCount``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.LongCount``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Decimal}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Double}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Int32}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Int64}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Single}) +System.Linq.Enumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +System.Linq.Enumerable.Max``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Decimal}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Double}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Int32}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Int64}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Single}) +System.Linq.Enumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +System.Linq.Enumerable.Min``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.OfType``1(System.Collections.IEnumerable) +System.Linq.Enumerable.OrderByDescending``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.OrderByDescending``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +System.Linq.Enumerable.OrderDescending``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.OrderDescending``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +System.Linq.Enumerable.Order``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Order``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +System.Linq.Enumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.Range(System.Int32,System.Int32) +System.Linq.Enumerable.Repeat``1(``0,System.Int32) +System.Linq.Enumerable.Reverse``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.SelectMany``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}}) +System.Linq.Enumerable.SelectMany``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Collections.Generic.IEnumerable{``1}}) +System.Linq.Enumerable.SelectMany``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) +System.Linq.Enumerable.SelectMany``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) +System.Linq.Enumerable.Select``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,``1}) +System.Linq.Enumerable.Select``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.SequenceEqual``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.SequenceEqual``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) +System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) +System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.SkipWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.SkipWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) +System.Linq.Enumerable.Skip``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Decimal}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Double}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Int32}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Int64}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Single}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +System.Linq.Enumerable.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.TakeWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.TakeWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) +System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Range) +System.Linq.Enumerable.ThenByDescending``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.ThenByDescending``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +System.Linq.Enumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +System.Linq.Enumerable.ToArray``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}}) +System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.ToDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +System.Linq.Enumerable.ToDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.ToList``1(System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.ToLookup``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.ToLookup``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.ToLookup``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +System.Linq.Enumerable.ToLookup``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.TryGetNonEnumeratedCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32@) +System.Linq.Enumerable.UnionBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +System.Linq.Enumerable.UnionBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +System.Linq.Enumerable.Union``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +System.Linq.Enumerable.Union``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +System.Linq.Enumerable.Where``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +System.Linq.Enumerable.Where``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) +System.Linq.Enumerable.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1}) +System.Linq.Enumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2}) +System.Linq.Enumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2}) +System.Linq.IGrouping`2 +System.Linq.IGrouping`2.get_Key +System.Linq.ILookup`2 +System.Linq.ILookup`2.Contains(`0) +System.Linq.ILookup`2.get_Count +System.Linq.ILookup`2.get_Item(`0) +System.Linq.IOrderedEnumerable`1 +System.Linq.IOrderedEnumerable`1.CreateOrderedEnumerable``1(System.Func{`0,``0},System.Collections.Generic.IComparer{``0},System.Boolean) +System.Linq.Lookup`2 +System.Linq.Lookup`2.ApplyResultSelector``1(System.Func{`0,System.Collections.Generic.IEnumerable{`1},``0}) +System.Linq.Lookup`2.Contains(`0) +System.Linq.Lookup`2.GetEnumerator +System.Linq.Lookup`2.get_Count +System.Linq.Lookup`2.get_Item(`0) \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt new file mode 100644 index 0000000000000..aaf32c8766bbc --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt @@ -0,0 +1,7757 @@ +# Generated, do not update manually +System.AccessViolationException +System.AccessViolationException.#ctor +System.AccessViolationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.AccessViolationException.#ctor(System.String) +System.AccessViolationException.#ctor(System.String,System.Exception) +System.Action +System.Action.#ctor(System.Object,System.IntPtr) +System.Action.BeginInvoke(System.AsyncCallback,System.Object) +System.Action.EndInvoke(System.IAsyncResult) +System.Action.Invoke +System.Action`1 +System.Action`1.#ctor(System.Object,System.IntPtr) +System.Action`1.BeginInvoke(`0,System.AsyncCallback,System.Object) +System.Action`1.EndInvoke(System.IAsyncResult) +System.Action`1.Invoke(`0) +System.Action`10 +System.Action`10.#ctor(System.Object,System.IntPtr) +System.Action`10.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,System.AsyncCallback,System.Object) +System.Action`10.EndInvoke(System.IAsyncResult) +System.Action`10.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9) +System.Action`11 +System.Action`11.#ctor(System.Object,System.IntPtr) +System.Action`11.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,System.AsyncCallback,System.Object) +System.Action`11.EndInvoke(System.IAsyncResult) +System.Action`11.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10) +System.Action`12 +System.Action`12.#ctor(System.Object,System.IntPtr) +System.Action`12.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,System.AsyncCallback,System.Object) +System.Action`12.EndInvoke(System.IAsyncResult) +System.Action`12.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11) +System.Action`13 +System.Action`13.#ctor(System.Object,System.IntPtr) +System.Action`13.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,System.AsyncCallback,System.Object) +System.Action`13.EndInvoke(System.IAsyncResult) +System.Action`13.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12) +System.Action`14 +System.Action`14.#ctor(System.Object,System.IntPtr) +System.Action`14.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,System.AsyncCallback,System.Object) +System.Action`14.EndInvoke(System.IAsyncResult) +System.Action`14.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13) +System.Action`15 +System.Action`15.#ctor(System.Object,System.IntPtr) +System.Action`15.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,System.AsyncCallback,System.Object) +System.Action`15.EndInvoke(System.IAsyncResult) +System.Action`15.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14) +System.Action`16 +System.Action`16.#ctor(System.Object,System.IntPtr) +System.Action`16.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15,System.AsyncCallback,System.Object) +System.Action`16.EndInvoke(System.IAsyncResult) +System.Action`16.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15) +System.Action`2 +System.Action`2.#ctor(System.Object,System.IntPtr) +System.Action`2.BeginInvoke(`0,`1,System.AsyncCallback,System.Object) +System.Action`2.EndInvoke(System.IAsyncResult) +System.Action`2.Invoke(`0,`1) +System.Action`3 +System.Action`3.#ctor(System.Object,System.IntPtr) +System.Action`3.BeginInvoke(`0,`1,`2,System.AsyncCallback,System.Object) +System.Action`3.EndInvoke(System.IAsyncResult) +System.Action`3.Invoke(`0,`1,`2) +System.Action`4 +System.Action`4.#ctor(System.Object,System.IntPtr) +System.Action`4.BeginInvoke(`0,`1,`2,`3,System.AsyncCallback,System.Object) +System.Action`4.EndInvoke(System.IAsyncResult) +System.Action`4.Invoke(`0,`1,`2,`3) +System.Action`5 +System.Action`5.#ctor(System.Object,System.IntPtr) +System.Action`5.BeginInvoke(`0,`1,`2,`3,`4,System.AsyncCallback,System.Object) +System.Action`5.EndInvoke(System.IAsyncResult) +System.Action`5.Invoke(`0,`1,`2,`3,`4) +System.Action`6 +System.Action`6.#ctor(System.Object,System.IntPtr) +System.Action`6.BeginInvoke(`0,`1,`2,`3,`4,`5,System.AsyncCallback,System.Object) +System.Action`6.EndInvoke(System.IAsyncResult) +System.Action`6.Invoke(`0,`1,`2,`3,`4,`5) +System.Action`7 +System.Action`7.#ctor(System.Object,System.IntPtr) +System.Action`7.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,System.AsyncCallback,System.Object) +System.Action`7.EndInvoke(System.IAsyncResult) +System.Action`7.Invoke(`0,`1,`2,`3,`4,`5,`6) +System.Action`8 +System.Action`8.#ctor(System.Object,System.IntPtr) +System.Action`8.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,System.AsyncCallback,System.Object) +System.Action`8.EndInvoke(System.IAsyncResult) +System.Action`8.Invoke(`0,`1,`2,`3,`4,`5,`6,`7) +System.Action`9 +System.Action`9.#ctor(System.Object,System.IntPtr) +System.Action`9.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,System.AsyncCallback,System.Object) +System.Action`9.EndInvoke(System.IAsyncResult) +System.Action`9.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8) +System.AggregateException +System.AggregateException.#ctor +System.AggregateException.#ctor(System.Collections.Generic.IEnumerable{System.Exception}) +System.AggregateException.#ctor(System.Exception[]) +System.AggregateException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.AggregateException.#ctor(System.String) +System.AggregateException.#ctor(System.String,System.Collections.Generic.IEnumerable{System.Exception}) +System.AggregateException.#ctor(System.String,System.Exception) +System.AggregateException.#ctor(System.String,System.Exception[]) +System.AggregateException.Flatten +System.AggregateException.GetBaseException +System.AggregateException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.AggregateException.Handle(System.Func{System.Exception,System.Boolean}) +System.AggregateException.ToString +System.AggregateException.get_InnerExceptions +System.AggregateException.get_Message +System.ApplicationException +System.ApplicationException.#ctor +System.ApplicationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ApplicationException.#ctor(System.String) +System.ApplicationException.#ctor(System.String,System.Exception) +System.ApplicationId +System.ApplicationId.#ctor(System.Byte[],System.String,System.Version,System.String,System.String) +System.ApplicationId.Copy +System.ApplicationId.Equals(System.Object) +System.ApplicationId.GetHashCode +System.ApplicationId.ToString +System.ApplicationId.get_Culture +System.ApplicationId.get_Name +System.ApplicationId.get_ProcessorArchitecture +System.ApplicationId.get_PublicKeyToken +System.ApplicationId.get_Version +System.ArgIterator +System.ArgIterator.#ctor(System.RuntimeArgumentHandle) +System.ArgIterator.#ctor(System.RuntimeArgumentHandle,System.Void*) +System.ArgIterator.End +System.ArgIterator.Equals(System.Object) +System.ArgIterator.GetHashCode +System.ArgIterator.GetNextArg +System.ArgIterator.GetNextArg(System.RuntimeTypeHandle) +System.ArgIterator.GetNextArgType +System.ArgIterator.GetRemainingCount +System.ArgumentException +System.ArgumentException.#ctor +System.ArgumentException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArgumentException.#ctor(System.String) +System.ArgumentException.#ctor(System.String,System.Exception) +System.ArgumentException.#ctor(System.String,System.String) +System.ArgumentException.#ctor(System.String,System.String,System.Exception) +System.ArgumentException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArgumentException.ThrowIfNullOrEmpty(System.String,System.String) +System.ArgumentException.ThrowIfNullOrWhiteSpace(System.String,System.String) +System.ArgumentException.get_Message +System.ArgumentException.get_ParamName +System.ArgumentNullException +System.ArgumentNullException.#ctor +System.ArgumentNullException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArgumentNullException.#ctor(System.String) +System.ArgumentNullException.#ctor(System.String,System.Exception) +System.ArgumentNullException.#ctor(System.String,System.String) +System.ArgumentNullException.ThrowIfNull(System.Object,System.String) +System.ArgumentNullException.ThrowIfNull(System.Void*,System.String) +System.ArgumentOutOfRangeException +System.ArgumentOutOfRangeException.#ctor +System.ArgumentOutOfRangeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArgumentOutOfRangeException.#ctor(System.String) +System.ArgumentOutOfRangeException.#ctor(System.String,System.Exception) +System.ArgumentOutOfRangeException.#ctor(System.String,System.Object,System.String) +System.ArgumentOutOfRangeException.#ctor(System.String,System.String) +System.ArgumentOutOfRangeException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArgumentOutOfRangeException.ThrowIfEqual``1(``0,``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual``1(``0,``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfGreaterThan``1(``0,``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfLessThanOrEqual``1(``0,``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfLessThan``1(``0,``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfNegativeOrZero``1(``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfNegative``1(``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfNotEqual``1(``0,``0,System.String) +System.ArgumentOutOfRangeException.ThrowIfZero``1(``0,System.String) +System.ArgumentOutOfRangeException.get_ActualValue +System.ArgumentOutOfRangeException.get_Message +System.ArithmeticException +System.ArithmeticException.#ctor +System.ArithmeticException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArithmeticException.#ctor(System.String) +System.ArithmeticException.#ctor(System.String,System.Exception) +System.Array +System.Array.AsReadOnly``1(``0[]) +System.Array.BinarySearch(System.Array,System.Int32,System.Int32,System.Object) +System.Array.BinarySearch(System.Array,System.Int32,System.Int32,System.Object,System.Collections.IComparer) +System.Array.BinarySearch(System.Array,System.Object) +System.Array.BinarySearch(System.Array,System.Object,System.Collections.IComparer) +System.Array.BinarySearch``1(``0[],System.Int32,System.Int32,``0) +System.Array.BinarySearch``1(``0[],System.Int32,System.Int32,``0,System.Collections.Generic.IComparer{``0}) +System.Array.BinarySearch``1(``0[],``0) +System.Array.BinarySearch``1(``0[],``0,System.Collections.Generic.IComparer{``0}) +System.Array.Clear(System.Array) +System.Array.Clear(System.Array,System.Int32,System.Int32) +System.Array.Clone +System.Array.ConstrainedCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) +System.Array.ConvertAll``2(``0[],System.Converter{``0,``1}) +System.Array.Copy(System.Array,System.Array,System.Int32) +System.Array.Copy(System.Array,System.Array,System.Int64) +System.Array.Copy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) +System.Array.Copy(System.Array,System.Int64,System.Array,System.Int64,System.Int64) +System.Array.CopyTo(System.Array,System.Int32) +System.Array.CopyTo(System.Array,System.Int64) +System.Array.CreateInstance(System.Type,System.Int32) +System.Array.CreateInstance(System.Type,System.Int32,System.Int32) +System.Array.CreateInstance(System.Type,System.Int32,System.Int32,System.Int32) +System.Array.CreateInstance(System.Type,System.Int32[]) +System.Array.CreateInstance(System.Type,System.Int32[],System.Int32[]) +System.Array.CreateInstance(System.Type,System.Int64[]) +System.Array.CreateInstanceFromArrayType(System.Type,System.Int32) +System.Array.CreateInstanceFromArrayType(System.Type,System.Int32[]) +System.Array.CreateInstanceFromArrayType(System.Type,System.Int32[],System.Int32[]) +System.Array.Empty``1 +System.Array.Exists``1(``0[],System.Predicate{``0}) +System.Array.Fill``1(``0[],``0) +System.Array.Fill``1(``0[],``0,System.Int32,System.Int32) +System.Array.FindAll``1(``0[],System.Predicate{``0}) +System.Array.FindIndex``1(``0[],System.Int32,System.Int32,System.Predicate{``0}) +System.Array.FindIndex``1(``0[],System.Int32,System.Predicate{``0}) +System.Array.FindIndex``1(``0[],System.Predicate{``0}) +System.Array.FindLastIndex``1(``0[],System.Int32,System.Int32,System.Predicate{``0}) +System.Array.FindLastIndex``1(``0[],System.Int32,System.Predicate{``0}) +System.Array.FindLastIndex``1(``0[],System.Predicate{``0}) +System.Array.FindLast``1(``0[],System.Predicate{``0}) +System.Array.Find``1(``0[],System.Predicate{``0}) +System.Array.ForEach``1(``0[],System.Action{``0}) +System.Array.GetEnumerator +System.Array.GetLength(System.Int32) +System.Array.GetLongLength(System.Int32) +System.Array.GetLowerBound(System.Int32) +System.Array.GetUpperBound(System.Int32) +System.Array.GetValue(System.Int32) +System.Array.GetValue(System.Int32,System.Int32) +System.Array.GetValue(System.Int32,System.Int32,System.Int32) +System.Array.GetValue(System.Int32[]) +System.Array.GetValue(System.Int64) +System.Array.GetValue(System.Int64,System.Int64) +System.Array.GetValue(System.Int64,System.Int64,System.Int64) +System.Array.GetValue(System.Int64[]) +System.Array.IndexOf(System.Array,System.Object) +System.Array.IndexOf(System.Array,System.Object,System.Int32) +System.Array.IndexOf(System.Array,System.Object,System.Int32,System.Int32) +System.Array.IndexOf``1(``0[],``0) +System.Array.IndexOf``1(``0[],``0,System.Int32) +System.Array.IndexOf``1(``0[],``0,System.Int32,System.Int32) +System.Array.Initialize +System.Array.LastIndexOf(System.Array,System.Object) +System.Array.LastIndexOf(System.Array,System.Object,System.Int32) +System.Array.LastIndexOf(System.Array,System.Object,System.Int32,System.Int32) +System.Array.LastIndexOf``1(``0[],``0) +System.Array.LastIndexOf``1(``0[],``0,System.Int32) +System.Array.LastIndexOf``1(``0[],``0,System.Int32,System.Int32) +System.Array.Resize``1(``0[]@,System.Int32) +System.Array.Reverse(System.Array) +System.Array.Reverse(System.Array,System.Int32,System.Int32) +System.Array.Reverse``1(``0[]) +System.Array.Reverse``1(``0[],System.Int32,System.Int32) +System.Array.SetValue(System.Object,System.Int32) +System.Array.SetValue(System.Object,System.Int32,System.Int32) +System.Array.SetValue(System.Object,System.Int32,System.Int32,System.Int32) +System.Array.SetValue(System.Object,System.Int32[]) +System.Array.SetValue(System.Object,System.Int64) +System.Array.SetValue(System.Object,System.Int64,System.Int64) +System.Array.SetValue(System.Object,System.Int64,System.Int64,System.Int64) +System.Array.SetValue(System.Object,System.Int64[]) +System.Array.Sort(System.Array) +System.Array.Sort(System.Array,System.Array) +System.Array.Sort(System.Array,System.Array,System.Collections.IComparer) +System.Array.Sort(System.Array,System.Array,System.Int32,System.Int32) +System.Array.Sort(System.Array,System.Array,System.Int32,System.Int32,System.Collections.IComparer) +System.Array.Sort(System.Array,System.Collections.IComparer) +System.Array.Sort(System.Array,System.Int32,System.Int32) +System.Array.Sort(System.Array,System.Int32,System.Int32,System.Collections.IComparer) +System.Array.Sort``1(``0[]) +System.Array.Sort``1(``0[],System.Collections.Generic.IComparer{``0}) +System.Array.Sort``1(``0[],System.Comparison{``0}) +System.Array.Sort``1(``0[],System.Int32,System.Int32) +System.Array.Sort``1(``0[],System.Int32,System.Int32,System.Collections.Generic.IComparer{``0}) +System.Array.Sort``2(``0[],``1[]) +System.Array.Sort``2(``0[],``1[],System.Collections.Generic.IComparer{``0}) +System.Array.Sort``2(``0[],``1[],System.Int32,System.Int32) +System.Array.Sort``2(``0[],``1[],System.Int32,System.Int32,System.Collections.Generic.IComparer{``0}) +System.Array.TrueForAll``1(``0[],System.Predicate{``0}) +System.Array.get_IsFixedSize +System.Array.get_IsReadOnly +System.Array.get_IsSynchronized +System.Array.get_Length +System.Array.get_LongLength +System.Array.get_MaxLength +System.Array.get_Rank +System.Array.get_SyncRoot +System.ArraySegment`1 +System.ArraySegment`1.#ctor(`0[]) +System.ArraySegment`1.#ctor(`0[],System.Int32,System.Int32) +System.ArraySegment`1.CopyTo(System.ArraySegment{`0}) +System.ArraySegment`1.CopyTo(`0[]) +System.ArraySegment`1.CopyTo(`0[],System.Int32) +System.ArraySegment`1.Enumerator +System.ArraySegment`1.Enumerator.Dispose +System.ArraySegment`1.Enumerator.MoveNext +System.ArraySegment`1.Enumerator.get_Current +System.ArraySegment`1.Equals(System.ArraySegment{`0}) +System.ArraySegment`1.Equals(System.Object) +System.ArraySegment`1.GetEnumerator +System.ArraySegment`1.GetHashCode +System.ArraySegment`1.Slice(System.Int32) +System.ArraySegment`1.Slice(System.Int32,System.Int32) +System.ArraySegment`1.ToArray +System.ArraySegment`1.get_Array +System.ArraySegment`1.get_Count +System.ArraySegment`1.get_Empty +System.ArraySegment`1.get_Item(System.Int32) +System.ArraySegment`1.get_Offset +System.ArraySegment`1.op_Equality(System.ArraySegment{`0},System.ArraySegment{`0}) +System.ArraySegment`1.op_Implicit(`0[])~System.ArraySegment{`0} +System.ArraySegment`1.op_Inequality(System.ArraySegment{`0},System.ArraySegment{`0}) +System.ArraySegment`1.set_Item(System.Int32,`0) +System.ArrayTypeMismatchException +System.ArrayTypeMismatchException.#ctor +System.ArrayTypeMismatchException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ArrayTypeMismatchException.#ctor(System.String) +System.ArrayTypeMismatchException.#ctor(System.String,System.Exception) +System.AsyncCallback +System.AsyncCallback.#ctor(System.Object,System.IntPtr) +System.AsyncCallback.BeginInvoke(System.IAsyncResult,System.AsyncCallback,System.Object) +System.AsyncCallback.EndInvoke(System.IAsyncResult) +System.AsyncCallback.Invoke(System.IAsyncResult) +System.Attribute +System.Attribute.#ctor +System.Attribute.Equals(System.Object) +System.Attribute.GetCustomAttribute(System.Reflection.Assembly,System.Type) +System.Attribute.GetCustomAttribute(System.Reflection.Assembly,System.Type,System.Boolean) +System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,System.Type) +System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,System.Type,System.Boolean) +System.Attribute.GetCustomAttribute(System.Reflection.Module,System.Type) +System.Attribute.GetCustomAttribute(System.Reflection.Module,System.Type,System.Boolean) +System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,System.Type) +System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,System.Type,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.Assembly) +System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Type) +System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Type,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo) +System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Type) +System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Type,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.Module) +System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Type) +System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Type,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo) +System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Boolean) +System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Type) +System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Type,System.Boolean) +System.Attribute.GetHashCode +System.Attribute.IsDefaultAttribute +System.Attribute.IsDefined(System.Reflection.Assembly,System.Type) +System.Attribute.IsDefined(System.Reflection.Assembly,System.Type,System.Boolean) +System.Attribute.IsDefined(System.Reflection.MemberInfo,System.Type) +System.Attribute.IsDefined(System.Reflection.MemberInfo,System.Type,System.Boolean) +System.Attribute.IsDefined(System.Reflection.Module,System.Type) +System.Attribute.IsDefined(System.Reflection.Module,System.Type,System.Boolean) +System.Attribute.IsDefined(System.Reflection.ParameterInfo,System.Type) +System.Attribute.IsDefined(System.Reflection.ParameterInfo,System.Type,System.Boolean) +System.Attribute.Match(System.Object) +System.Attribute.get_TypeId +System.AttributeTargets +System.AttributeTargets.All +System.AttributeTargets.Assembly +System.AttributeTargets.Class +System.AttributeTargets.Constructor +System.AttributeTargets.Delegate +System.AttributeTargets.Enum +System.AttributeTargets.Event +System.AttributeTargets.Field +System.AttributeTargets.GenericParameter +System.AttributeTargets.Interface +System.AttributeTargets.Method +System.AttributeTargets.Module +System.AttributeTargets.Parameter +System.AttributeTargets.Property +System.AttributeTargets.ReturnValue +System.AttributeTargets.Struct +System.AttributeUsageAttribute +System.AttributeUsageAttribute.#ctor(System.AttributeTargets) +System.AttributeUsageAttribute.get_AllowMultiple +System.AttributeUsageAttribute.get_Inherited +System.AttributeUsageAttribute.get_ValidOn +System.AttributeUsageAttribute.set_AllowMultiple(System.Boolean) +System.AttributeUsageAttribute.set_Inherited(System.Boolean) +System.BadImageFormatException +System.BadImageFormatException.#ctor +System.BadImageFormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.BadImageFormatException.#ctor(System.String) +System.BadImageFormatException.#ctor(System.String,System.Exception) +System.BadImageFormatException.#ctor(System.String,System.String) +System.BadImageFormatException.#ctor(System.String,System.String,System.Exception) +System.BadImageFormatException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.BadImageFormatException.ToString +System.BadImageFormatException.get_FileName +System.BadImageFormatException.get_FusionLog +System.BadImageFormatException.get_Message +System.Base64FormattingOptions +System.Base64FormattingOptions.InsertLineBreaks +System.Base64FormattingOptions.None +System.BitConverter +System.BitConverter.DoubleToInt64Bits(System.Double) +System.BitConverter.DoubleToUInt64Bits(System.Double) +System.BitConverter.GetBytes(System.Boolean) +System.BitConverter.GetBytes(System.Char) +System.BitConverter.GetBytes(System.Double) +System.BitConverter.GetBytes(System.Half) +System.BitConverter.GetBytes(System.Int128) +System.BitConverter.GetBytes(System.Int16) +System.BitConverter.GetBytes(System.Int32) +System.BitConverter.GetBytes(System.Int64) +System.BitConverter.GetBytes(System.Single) +System.BitConverter.GetBytes(System.UInt128) +System.BitConverter.GetBytes(System.UInt16) +System.BitConverter.GetBytes(System.UInt32) +System.BitConverter.GetBytes(System.UInt64) +System.BitConverter.HalfToInt16Bits(System.Half) +System.BitConverter.HalfToUInt16Bits(System.Half) +System.BitConverter.Int16BitsToHalf(System.Int16) +System.BitConverter.Int32BitsToSingle(System.Int32) +System.BitConverter.Int64BitsToDouble(System.Int64) +System.BitConverter.IsLittleEndian +System.BitConverter.SingleToInt32Bits(System.Single) +System.BitConverter.SingleToUInt32Bits(System.Single) +System.BitConverter.ToBoolean(System.Byte[],System.Int32) +System.BitConverter.ToBoolean(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToChar(System.Byte[],System.Int32) +System.BitConverter.ToChar(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToDouble(System.Byte[],System.Int32) +System.BitConverter.ToDouble(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToHalf(System.Byte[],System.Int32) +System.BitConverter.ToHalf(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToInt128(System.Byte[],System.Int32) +System.BitConverter.ToInt128(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToInt16(System.Byte[],System.Int32) +System.BitConverter.ToInt16(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToInt32(System.Byte[],System.Int32) +System.BitConverter.ToInt32(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToInt64(System.Byte[],System.Int32) +System.BitConverter.ToInt64(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToSingle(System.Byte[],System.Int32) +System.BitConverter.ToSingle(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToString(System.Byte[]) +System.BitConverter.ToString(System.Byte[],System.Int32) +System.BitConverter.ToString(System.Byte[],System.Int32,System.Int32) +System.BitConverter.ToUInt128(System.Byte[],System.Int32) +System.BitConverter.ToUInt128(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToUInt16(System.Byte[],System.Int32) +System.BitConverter.ToUInt16(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToUInt32(System.Byte[],System.Int32) +System.BitConverter.ToUInt32(System.ReadOnlySpan{System.Byte}) +System.BitConverter.ToUInt64(System.Byte[],System.Int32) +System.BitConverter.ToUInt64(System.ReadOnlySpan{System.Byte}) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Boolean) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Char) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Double) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Half) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int128) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int16) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int32) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int64) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Single) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt128) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt16) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt32) +System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt64) +System.BitConverter.UInt16BitsToHalf(System.UInt16) +System.BitConverter.UInt32BitsToSingle(System.UInt32) +System.BitConverter.UInt64BitsToDouble(System.UInt64) +System.Boolean +System.Boolean.CompareTo(System.Boolean) +System.Boolean.CompareTo(System.Object) +System.Boolean.Equals(System.Boolean) +System.Boolean.Equals(System.Object) +System.Boolean.FalseString +System.Boolean.GetHashCode +System.Boolean.GetTypeCode +System.Boolean.Parse(System.ReadOnlySpan{System.Char}) +System.Boolean.Parse(System.String) +System.Boolean.ToString +System.Boolean.ToString(System.IFormatProvider) +System.Boolean.TrueString +System.Boolean.TryFormat(System.Span{System.Char},System.Int32@) +System.Boolean.TryParse(System.ReadOnlySpan{System.Char},System.Boolean@) +System.Boolean.TryParse(System.String,System.Boolean@) +System.Buffer +System.Buffer.BlockCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) +System.Buffer.ByteLength(System.Array) +System.Buffer.GetByte(System.Array,System.Int32) +System.Buffer.MemoryCopy(System.Void*,System.Void*,System.Int64,System.Int64) +System.Buffer.MemoryCopy(System.Void*,System.Void*,System.UInt64,System.UInt64) +System.Buffer.SetByte(System.Array,System.Int32,System.Byte) +System.Buffers.ArrayPool`1 +System.Buffers.ArrayPool`1.#ctor +System.Buffers.ArrayPool`1.Create +System.Buffers.ArrayPool`1.Create(System.Int32,System.Int32) +System.Buffers.ArrayPool`1.Rent(System.Int32) +System.Buffers.ArrayPool`1.Return(`0[],System.Boolean) +System.Buffers.ArrayPool`1.get_Shared +System.Buffers.IMemoryOwner`1 +System.Buffers.IMemoryOwner`1.get_Memory +System.Buffers.IPinnable +System.Buffers.IPinnable.Pin(System.Int32) +System.Buffers.IPinnable.Unpin +System.Buffers.MemoryHandle +System.Buffers.MemoryHandle.#ctor(System.Void*,System.Runtime.InteropServices.GCHandle,System.Buffers.IPinnable) +System.Buffers.MemoryHandle.Dispose +System.Buffers.MemoryHandle.get_Pointer +System.Buffers.MemoryManager`1 +System.Buffers.MemoryManager`1.#ctor +System.Buffers.MemoryManager`1.CreateMemory(System.Int32) +System.Buffers.MemoryManager`1.CreateMemory(System.Int32,System.Int32) +System.Buffers.MemoryManager`1.Dispose(System.Boolean) +System.Buffers.MemoryManager`1.GetSpan +System.Buffers.MemoryManager`1.Pin(System.Int32) +System.Buffers.MemoryManager`1.TryGetArray(System.ArraySegment{`0}@) +System.Buffers.MemoryManager`1.Unpin +System.Buffers.MemoryManager`1.get_Memory +System.Buffers.OperationStatus +System.Buffers.OperationStatus.DestinationTooSmall +System.Buffers.OperationStatus.Done +System.Buffers.OperationStatus.InvalidData +System.Buffers.OperationStatus.NeedMoreData +System.Buffers.ReadOnlySpanAction`2 +System.Buffers.ReadOnlySpanAction`2.#ctor(System.Object,System.IntPtr) +System.Buffers.ReadOnlySpanAction`2.BeginInvoke(System.ReadOnlySpan{`0},`1,System.AsyncCallback,System.Object) +System.Buffers.ReadOnlySpanAction`2.EndInvoke(System.IAsyncResult) +System.Buffers.ReadOnlySpanAction`2.Invoke(System.ReadOnlySpan{`0},`1) +System.Buffers.SearchValues +System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Byte}) +System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Char}) +System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.String},System.StringComparison) +System.Buffers.SearchValues`1 +System.Buffers.SearchValues`1.Contains(`0) +System.Buffers.SpanAction`2 +System.Buffers.SpanAction`2.#ctor(System.Object,System.IntPtr) +System.Buffers.SpanAction`2.BeginInvoke(System.Span{`0},`1,System.AsyncCallback,System.Object) +System.Buffers.SpanAction`2.EndInvoke(System.IAsyncResult) +System.Buffers.SpanAction`2.Invoke(System.Span{`0},`1) +System.Buffers.Text.Base64 +System.Buffers.Text.Base64.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +System.Buffers.Text.Base64.DecodeFromUtf8InPlace(System.Span{System.Byte},System.Int32@) +System.Buffers.Text.Base64.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +System.Buffers.Text.Base64.EncodeToUtf8InPlace(System.Span{System.Byte},System.Int32,System.Int32@) +System.Buffers.Text.Base64.GetMaxDecodedFromUtf8Length(System.Int32) +System.Buffers.Text.Base64.GetMaxEncodedToUtf8Length(System.Int32) +System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte}) +System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte},System.Int32@) +System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char}) +System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char},System.Int32@) +System.Buffers.Text.Base64Url +System.Buffers.Text.Base64Url.DecodeFromChars(System.ReadOnlySpan{System.Char}) +System.Buffers.Text.Base64Url.DecodeFromChars(System.ReadOnlySpan{System.Char},System.Span{System.Byte}) +System.Buffers.Text.Base64Url.DecodeFromChars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +System.Buffers.Text.Base64Url.DecodeFromUtf8(System.ReadOnlySpan{System.Byte}) +System.Buffers.Text.Base64Url.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte}) +System.Buffers.Text.Base64Url.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +System.Buffers.Text.Base64Url.DecodeFromUtf8InPlace(System.Span{System.Byte}) +System.Buffers.Text.Base64Url.EncodeToChars(System.ReadOnlySpan{System.Byte}) +System.Buffers.Text.Base64Url.EncodeToChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char}) +System.Buffers.Text.Base64Url.EncodeToChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Int32@,System.Boolean) +System.Buffers.Text.Base64Url.EncodeToString(System.ReadOnlySpan{System.Byte}) +System.Buffers.Text.Base64Url.EncodeToUtf8(System.ReadOnlySpan{System.Byte}) +System.Buffers.Text.Base64Url.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte}) +System.Buffers.Text.Base64Url.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +System.Buffers.Text.Base64Url.GetEncodedLength(System.Int32) +System.Buffers.Text.Base64Url.GetMaxDecodedLength(System.Int32) +System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Byte}) +System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Byte},System.Int32@) +System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Char}) +System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Char},System.Int32@) +System.Buffers.Text.Base64Url.TryDecodeFromChars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +System.Buffers.Text.Base64Url.TryDecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) +System.Buffers.Text.Base64Url.TryEncodeToChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Buffers.Text.Base64Url.TryEncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) +System.Buffers.Text.Base64Url.TryEncodeToUtf8InPlace(System.Span{System.Byte},System.Int32,System.Int32@) +System.Byte +System.Byte.Clamp(System.Byte,System.Byte,System.Byte) +System.Byte.CompareTo(System.Byte) +System.Byte.CompareTo(System.Object) +System.Byte.CreateChecked``1(``0) +System.Byte.CreateSaturating``1(``0) +System.Byte.CreateTruncating``1(``0) +System.Byte.DivRem(System.Byte,System.Byte) +System.Byte.Equals(System.Byte) +System.Byte.Equals(System.Object) +System.Byte.GetHashCode +System.Byte.GetTypeCode +System.Byte.IsEvenInteger(System.Byte) +System.Byte.IsOddInteger(System.Byte) +System.Byte.IsPow2(System.Byte) +System.Byte.LeadingZeroCount(System.Byte) +System.Byte.Log2(System.Byte) +System.Byte.Max(System.Byte,System.Byte) +System.Byte.MaxValue +System.Byte.Min(System.Byte,System.Byte) +System.Byte.MinValue +System.Byte.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Byte.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Byte.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Byte.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Byte.Parse(System.String) +System.Byte.Parse(System.String,System.Globalization.NumberStyles) +System.Byte.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Byte.Parse(System.String,System.IFormatProvider) +System.Byte.PopCount(System.Byte) +System.Byte.RotateLeft(System.Byte,System.Int32) +System.Byte.RotateRight(System.Byte,System.Int32) +System.Byte.Sign(System.Byte) +System.Byte.ToString +System.Byte.ToString(System.IFormatProvider) +System.Byte.ToString(System.String) +System.Byte.ToString(System.String,System.IFormatProvider) +System.Byte.TrailingZeroCount(System.Byte) +System.Byte.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Byte.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.Byte@) +System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) +System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Byte@) +System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.Byte@) +System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) +System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Byte@) +System.Byte.TryParse(System.String,System.Byte@) +System.Byte.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) +System.Byte.TryParse(System.String,System.IFormatProvider,System.Byte@) +System.CLSCompliantAttribute +System.CLSCompliantAttribute.#ctor(System.Boolean) +System.CLSCompliantAttribute.get_IsCompliant +System.CannotUnloadAppDomainException +System.CannotUnloadAppDomainException.#ctor +System.CannotUnloadAppDomainException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.CannotUnloadAppDomainException.#ctor(System.String) +System.CannotUnloadAppDomainException.#ctor(System.String,System.Exception) +System.Char +System.Char.CompareTo(System.Char) +System.Char.CompareTo(System.Object) +System.Char.ConvertFromUtf32(System.Int32) +System.Char.ConvertToUtf32(System.Char,System.Char) +System.Char.ConvertToUtf32(System.String,System.Int32) +System.Char.Equals(System.Char) +System.Char.Equals(System.Object) +System.Char.GetHashCode +System.Char.GetNumericValue(System.Char) +System.Char.GetNumericValue(System.String,System.Int32) +System.Char.GetTypeCode +System.Char.GetUnicodeCategory(System.Char) +System.Char.GetUnicodeCategory(System.String,System.Int32) +System.Char.IsAscii(System.Char) +System.Char.IsAsciiDigit(System.Char) +System.Char.IsAsciiHexDigit(System.Char) +System.Char.IsAsciiHexDigitLower(System.Char) +System.Char.IsAsciiHexDigitUpper(System.Char) +System.Char.IsAsciiLetter(System.Char) +System.Char.IsAsciiLetterLower(System.Char) +System.Char.IsAsciiLetterOrDigit(System.Char) +System.Char.IsAsciiLetterUpper(System.Char) +System.Char.IsBetween(System.Char,System.Char,System.Char) +System.Char.IsControl(System.Char) +System.Char.IsControl(System.String,System.Int32) +System.Char.IsDigit(System.Char) +System.Char.IsDigit(System.String,System.Int32) +System.Char.IsHighSurrogate(System.Char) +System.Char.IsHighSurrogate(System.String,System.Int32) +System.Char.IsLetter(System.Char) +System.Char.IsLetter(System.String,System.Int32) +System.Char.IsLetterOrDigit(System.Char) +System.Char.IsLetterOrDigit(System.String,System.Int32) +System.Char.IsLowSurrogate(System.Char) +System.Char.IsLowSurrogate(System.String,System.Int32) +System.Char.IsLower(System.Char) +System.Char.IsLower(System.String,System.Int32) +System.Char.IsNumber(System.Char) +System.Char.IsNumber(System.String,System.Int32) +System.Char.IsPunctuation(System.Char) +System.Char.IsPunctuation(System.String,System.Int32) +System.Char.IsSeparator(System.Char) +System.Char.IsSeparator(System.String,System.Int32) +System.Char.IsSurrogate(System.Char) +System.Char.IsSurrogate(System.String,System.Int32) +System.Char.IsSurrogatePair(System.Char,System.Char) +System.Char.IsSurrogatePair(System.String,System.Int32) +System.Char.IsSymbol(System.Char) +System.Char.IsSymbol(System.String,System.Int32) +System.Char.IsUpper(System.Char) +System.Char.IsUpper(System.String,System.Int32) +System.Char.IsWhiteSpace(System.Char) +System.Char.IsWhiteSpace(System.String,System.Int32) +System.Char.MaxValue +System.Char.MinValue +System.Char.Parse(System.String) +System.Char.ToLower(System.Char) +System.Char.ToLower(System.Char,System.Globalization.CultureInfo) +System.Char.ToLowerInvariant(System.Char) +System.Char.ToString +System.Char.ToString(System.Char) +System.Char.ToString(System.IFormatProvider) +System.Char.ToUpper(System.Char) +System.Char.ToUpper(System.Char,System.Globalization.CultureInfo) +System.Char.ToUpperInvariant(System.Char) +System.Char.TryParse(System.String,System.Char@) +System.CharEnumerator +System.CharEnumerator.Clone +System.CharEnumerator.Dispose +System.CharEnumerator.MoveNext +System.CharEnumerator.Reset +System.CharEnumerator.get_Current +System.Collections.ArrayList +System.Collections.ArrayList.#ctor +System.Collections.ArrayList.#ctor(System.Collections.ICollection) +System.Collections.ArrayList.#ctor(System.Int32) +System.Collections.ArrayList.Adapter(System.Collections.IList) +System.Collections.ArrayList.Add(System.Object) +System.Collections.ArrayList.AddRange(System.Collections.ICollection) +System.Collections.ArrayList.BinarySearch(System.Int32,System.Int32,System.Object,System.Collections.IComparer) +System.Collections.ArrayList.BinarySearch(System.Object) +System.Collections.ArrayList.BinarySearch(System.Object,System.Collections.IComparer) +System.Collections.ArrayList.Clear +System.Collections.ArrayList.Clone +System.Collections.ArrayList.Contains(System.Object) +System.Collections.ArrayList.CopyTo(System.Array) +System.Collections.ArrayList.CopyTo(System.Array,System.Int32) +System.Collections.ArrayList.CopyTo(System.Int32,System.Array,System.Int32,System.Int32) +System.Collections.ArrayList.FixedSize(System.Collections.ArrayList) +System.Collections.ArrayList.FixedSize(System.Collections.IList) +System.Collections.ArrayList.GetEnumerator +System.Collections.ArrayList.GetEnumerator(System.Int32,System.Int32) +System.Collections.ArrayList.GetRange(System.Int32,System.Int32) +System.Collections.ArrayList.IndexOf(System.Object) +System.Collections.ArrayList.IndexOf(System.Object,System.Int32) +System.Collections.ArrayList.IndexOf(System.Object,System.Int32,System.Int32) +System.Collections.ArrayList.Insert(System.Int32,System.Object) +System.Collections.ArrayList.InsertRange(System.Int32,System.Collections.ICollection) +System.Collections.ArrayList.LastIndexOf(System.Object) +System.Collections.ArrayList.LastIndexOf(System.Object,System.Int32) +System.Collections.ArrayList.LastIndexOf(System.Object,System.Int32,System.Int32) +System.Collections.ArrayList.ReadOnly(System.Collections.ArrayList) +System.Collections.ArrayList.ReadOnly(System.Collections.IList) +System.Collections.ArrayList.Remove(System.Object) +System.Collections.ArrayList.RemoveAt(System.Int32) +System.Collections.ArrayList.RemoveRange(System.Int32,System.Int32) +System.Collections.ArrayList.Repeat(System.Object,System.Int32) +System.Collections.ArrayList.Reverse +System.Collections.ArrayList.Reverse(System.Int32,System.Int32) +System.Collections.ArrayList.SetRange(System.Int32,System.Collections.ICollection) +System.Collections.ArrayList.Sort +System.Collections.ArrayList.Sort(System.Collections.IComparer) +System.Collections.ArrayList.Sort(System.Int32,System.Int32,System.Collections.IComparer) +System.Collections.ArrayList.Synchronized(System.Collections.ArrayList) +System.Collections.ArrayList.Synchronized(System.Collections.IList) +System.Collections.ArrayList.ToArray +System.Collections.ArrayList.ToArray(System.Type) +System.Collections.ArrayList.TrimToSize +System.Collections.ArrayList.get_Capacity +System.Collections.ArrayList.get_Count +System.Collections.ArrayList.get_IsFixedSize +System.Collections.ArrayList.get_IsReadOnly +System.Collections.ArrayList.get_IsSynchronized +System.Collections.ArrayList.get_Item(System.Int32) +System.Collections.ArrayList.get_SyncRoot +System.Collections.ArrayList.set_Capacity(System.Int32) +System.Collections.ArrayList.set_Item(System.Int32,System.Object) +System.Collections.Comparer +System.Collections.Comparer.#ctor(System.Globalization.CultureInfo) +System.Collections.Comparer.Compare(System.Object,System.Object) +System.Collections.Comparer.Default +System.Collections.Comparer.DefaultInvariant +System.Collections.Comparer.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.DictionaryEntry +System.Collections.DictionaryEntry.#ctor(System.Object,System.Object) +System.Collections.DictionaryEntry.Deconstruct(System.Object@,System.Object@) +System.Collections.DictionaryEntry.get_Key +System.Collections.DictionaryEntry.get_Value +System.Collections.DictionaryEntry.set_Key(System.Object) +System.Collections.DictionaryEntry.set_Value(System.Object) +System.Collections.Generic.IAlternateEqualityComparer`2 +System.Collections.Generic.IAlternateEqualityComparer`2.Create(`0) +System.Collections.Generic.IAlternateEqualityComparer`2.Equals(`0,`1) +System.Collections.Generic.IAlternateEqualityComparer`2.GetHashCode(`0) +System.Collections.Generic.IAsyncEnumerable`1 +System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken) +System.Collections.Generic.IAsyncEnumerator`1 +System.Collections.Generic.IAsyncEnumerator`1.MoveNextAsync +System.Collections.Generic.IAsyncEnumerator`1.get_Current +System.Collections.Generic.ICollection`1 +System.Collections.Generic.ICollection`1.Add(`0) +System.Collections.Generic.ICollection`1.Clear +System.Collections.Generic.ICollection`1.Contains(`0) +System.Collections.Generic.ICollection`1.CopyTo(`0[],System.Int32) +System.Collections.Generic.ICollection`1.Remove(`0) +System.Collections.Generic.ICollection`1.get_Count +System.Collections.Generic.ICollection`1.get_IsReadOnly +System.Collections.Generic.IComparer`1 +System.Collections.Generic.IComparer`1.Compare(`0,`0) +System.Collections.Generic.IDictionary`2 +System.Collections.Generic.IDictionary`2.Add(`0,`1) +System.Collections.Generic.IDictionary`2.ContainsKey(`0) +System.Collections.Generic.IDictionary`2.Remove(`0) +System.Collections.Generic.IDictionary`2.TryGetValue(`0,`1@) +System.Collections.Generic.IDictionary`2.get_Item(`0) +System.Collections.Generic.IDictionary`2.get_Keys +System.Collections.Generic.IDictionary`2.get_Values +System.Collections.Generic.IDictionary`2.set_Item(`0,`1) +System.Collections.Generic.IEnumerable`1 +System.Collections.Generic.IEnumerable`1.GetEnumerator +System.Collections.Generic.IEnumerator`1 +System.Collections.Generic.IEnumerator`1.get_Current +System.Collections.Generic.IEqualityComparer`1 +System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0) +System.Collections.Generic.IEqualityComparer`1.GetHashCode(`0) +System.Collections.Generic.IList`1 +System.Collections.Generic.IList`1.IndexOf(`0) +System.Collections.Generic.IList`1.Insert(System.Int32,`0) +System.Collections.Generic.IList`1.RemoveAt(System.Int32) +System.Collections.Generic.IList`1.get_Item(System.Int32) +System.Collections.Generic.IList`1.set_Item(System.Int32,`0) +System.Collections.Generic.IReadOnlyCollection`1 +System.Collections.Generic.IReadOnlyCollection`1.get_Count +System.Collections.Generic.IReadOnlyDictionary`2 +System.Collections.Generic.IReadOnlyDictionary`2.ContainsKey(`0) +System.Collections.Generic.IReadOnlyDictionary`2.TryGetValue(`0,`1@) +System.Collections.Generic.IReadOnlyDictionary`2.get_Item(`0) +System.Collections.Generic.IReadOnlyDictionary`2.get_Keys +System.Collections.Generic.IReadOnlyDictionary`2.get_Values +System.Collections.Generic.IReadOnlyList`1 +System.Collections.Generic.IReadOnlyList`1.get_Item(System.Int32) +System.Collections.Generic.IReadOnlySet`1 +System.Collections.Generic.IReadOnlySet`1.Contains(`0) +System.Collections.Generic.IReadOnlySet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.IReadOnlySet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.IReadOnlySet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.IReadOnlySet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.IReadOnlySet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.IReadOnlySet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1 +System.Collections.Generic.ISet`1.Add(`0) +System.Collections.Generic.ISet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.ISet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) +System.Collections.Generic.KeyNotFoundException +System.Collections.Generic.KeyNotFoundException.#ctor +System.Collections.Generic.KeyNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Generic.KeyNotFoundException.#ctor(System.String) +System.Collections.Generic.KeyNotFoundException.#ctor(System.String,System.Exception) +System.Collections.Generic.KeyValuePair +System.Collections.Generic.KeyValuePair.Create``2(``0,``1) +System.Collections.Generic.KeyValuePair`2 +System.Collections.Generic.KeyValuePair`2.#ctor(`0,`1) +System.Collections.Generic.KeyValuePair`2.Deconstruct(`0@,`1@) +System.Collections.Generic.KeyValuePair`2.ToString +System.Collections.Generic.KeyValuePair`2.get_Key +System.Collections.Generic.KeyValuePair`2.get_Value +System.Collections.Hashtable +System.Collections.Hashtable.#ctor +System.Collections.Hashtable.#ctor(System.Collections.IDictionary) +System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IEqualityComparer) +System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IHashCodeProvider,System.Collections.IComparer) +System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single) +System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single,System.Collections.IEqualityComparer) +System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single,System.Collections.IHashCodeProvider,System.Collections.IComparer) +System.Collections.Hashtable.#ctor(System.Collections.IEqualityComparer) +System.Collections.Hashtable.#ctor(System.Collections.IHashCodeProvider,System.Collections.IComparer) +System.Collections.Hashtable.#ctor(System.Int32) +System.Collections.Hashtable.#ctor(System.Int32,System.Collections.IEqualityComparer) +System.Collections.Hashtable.#ctor(System.Int32,System.Collections.IHashCodeProvider,System.Collections.IComparer) +System.Collections.Hashtable.#ctor(System.Int32,System.Single) +System.Collections.Hashtable.#ctor(System.Int32,System.Single,System.Collections.IEqualityComparer) +System.Collections.Hashtable.#ctor(System.Int32,System.Single,System.Collections.IHashCodeProvider,System.Collections.IComparer) +System.Collections.Hashtable.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Hashtable.Add(System.Object,System.Object) +System.Collections.Hashtable.Clear +System.Collections.Hashtable.Clone +System.Collections.Hashtable.Contains(System.Object) +System.Collections.Hashtable.ContainsKey(System.Object) +System.Collections.Hashtable.ContainsValue(System.Object) +System.Collections.Hashtable.CopyTo(System.Array,System.Int32) +System.Collections.Hashtable.GetEnumerator +System.Collections.Hashtable.GetHash(System.Object) +System.Collections.Hashtable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Collections.Hashtable.KeyEquals(System.Object,System.Object) +System.Collections.Hashtable.OnDeserialization(System.Object) +System.Collections.Hashtable.Remove(System.Object) +System.Collections.Hashtable.Synchronized(System.Collections.Hashtable) +System.Collections.Hashtable.get_Count +System.Collections.Hashtable.get_EqualityComparer +System.Collections.Hashtable.get_IsFixedSize +System.Collections.Hashtable.get_IsReadOnly +System.Collections.Hashtable.get_IsSynchronized +System.Collections.Hashtable.get_Item(System.Object) +System.Collections.Hashtable.get_Keys +System.Collections.Hashtable.get_SyncRoot +System.Collections.Hashtable.get_Values +System.Collections.Hashtable.get_comparer +System.Collections.Hashtable.get_hcp +System.Collections.Hashtable.set_Item(System.Object,System.Object) +System.Collections.Hashtable.set_comparer(System.Collections.IComparer) +System.Collections.Hashtable.set_hcp(System.Collections.IHashCodeProvider) +System.Collections.ICollection +System.Collections.ICollection.CopyTo(System.Array,System.Int32) +System.Collections.ICollection.get_Count +System.Collections.ICollection.get_IsSynchronized +System.Collections.ICollection.get_SyncRoot +System.Collections.IComparer +System.Collections.IComparer.Compare(System.Object,System.Object) +System.Collections.IDictionary +System.Collections.IDictionary.Add(System.Object,System.Object) +System.Collections.IDictionary.Clear +System.Collections.IDictionary.Contains(System.Object) +System.Collections.IDictionary.GetEnumerator +System.Collections.IDictionary.Remove(System.Object) +System.Collections.IDictionary.get_IsFixedSize +System.Collections.IDictionary.get_IsReadOnly +System.Collections.IDictionary.get_Item(System.Object) +System.Collections.IDictionary.get_Keys +System.Collections.IDictionary.get_Values +System.Collections.IDictionary.set_Item(System.Object,System.Object) +System.Collections.IDictionaryEnumerator +System.Collections.IDictionaryEnumerator.get_Entry +System.Collections.IDictionaryEnumerator.get_Key +System.Collections.IDictionaryEnumerator.get_Value +System.Collections.IEnumerable +System.Collections.IEnumerable.GetEnumerator +System.Collections.IEnumerator +System.Collections.IEnumerator.MoveNext +System.Collections.IEnumerator.Reset +System.Collections.IEnumerator.get_Current +System.Collections.IEqualityComparer +System.Collections.IEqualityComparer.Equals(System.Object,System.Object) +System.Collections.IEqualityComparer.GetHashCode(System.Object) +System.Collections.IHashCodeProvider +System.Collections.IHashCodeProvider.GetHashCode(System.Object) +System.Collections.IList +System.Collections.IList.Add(System.Object) +System.Collections.IList.Clear +System.Collections.IList.Contains(System.Object) +System.Collections.IList.IndexOf(System.Object) +System.Collections.IList.Insert(System.Int32,System.Object) +System.Collections.IList.Remove(System.Object) +System.Collections.IList.RemoveAt(System.Int32) +System.Collections.IList.get_IsFixedSize +System.Collections.IList.get_IsReadOnly +System.Collections.IList.get_Item(System.Int32) +System.Collections.IList.set_Item(System.Int32,System.Object) +System.Collections.IStructuralComparable +System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer) +System.Collections.IStructuralEquatable +System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer) +System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer) +System.Collections.ObjectModel.Collection`1 +System.Collections.ObjectModel.Collection`1.#ctor +System.Collections.ObjectModel.Collection`1.#ctor(System.Collections.Generic.IList{`0}) +System.Collections.ObjectModel.Collection`1.Add(`0) +System.Collections.ObjectModel.Collection`1.Clear +System.Collections.ObjectModel.Collection`1.ClearItems +System.Collections.ObjectModel.Collection`1.Contains(`0) +System.Collections.ObjectModel.Collection`1.CopyTo(`0[],System.Int32) +System.Collections.ObjectModel.Collection`1.GetEnumerator +System.Collections.ObjectModel.Collection`1.IndexOf(`0) +System.Collections.ObjectModel.Collection`1.Insert(System.Int32,`0) +System.Collections.ObjectModel.Collection`1.InsertItem(System.Int32,`0) +System.Collections.ObjectModel.Collection`1.Remove(`0) +System.Collections.ObjectModel.Collection`1.RemoveAt(System.Int32) +System.Collections.ObjectModel.Collection`1.RemoveItem(System.Int32) +System.Collections.ObjectModel.Collection`1.SetItem(System.Int32,`0) +System.Collections.ObjectModel.Collection`1.get_Count +System.Collections.ObjectModel.Collection`1.get_Item(System.Int32) +System.Collections.ObjectModel.Collection`1.get_Items +System.Collections.ObjectModel.Collection`1.set_Item(System.Int32,`0) +System.Collections.ObjectModel.ReadOnlyCollection`1 +System.Collections.ObjectModel.ReadOnlyCollection`1.#ctor(System.Collections.Generic.IList{`0}) +System.Collections.ObjectModel.ReadOnlyCollection`1.Contains(`0) +System.Collections.ObjectModel.ReadOnlyCollection`1.CopyTo(`0[],System.Int32) +System.Collections.ObjectModel.ReadOnlyCollection`1.GetEnumerator +System.Collections.ObjectModel.ReadOnlyCollection`1.IndexOf(`0) +System.Collections.ObjectModel.ReadOnlyCollection`1.get_Count +System.Collections.ObjectModel.ReadOnlyCollection`1.get_Empty +System.Collections.ObjectModel.ReadOnlyCollection`1.get_Item(System.Int32) +System.Collections.ObjectModel.ReadOnlyCollection`1.get_Items +System.Collections.ObjectModel.ReadOnlyDictionary`2 +System.Collections.ObjectModel.ReadOnlyDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +System.Collections.ObjectModel.ReadOnlyDictionary`2.ContainsKey(`0) +System.Collections.ObjectModel.ReadOnlyDictionary`2.GetEnumerator +System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection +System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.Contains(`0) +System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.GetEnumerator +System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.get_Count +System.Collections.ObjectModel.ReadOnlyDictionary`2.TryGetValue(`0,`1@) +System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection +System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.GetEnumerator +System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.get_Count +System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Count +System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Dictionary +System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Empty +System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Item(`0) +System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Keys +System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Values +System.Comparison`1 +System.Comparison`1.#ctor(System.Object,System.IntPtr) +System.Comparison`1.BeginInvoke(`0,`0,System.AsyncCallback,System.Object) +System.Comparison`1.EndInvoke(System.IAsyncResult) +System.Comparison`1.Invoke(`0,`0) +System.ComponentModel.DefaultValueAttribute +System.ComponentModel.DefaultValueAttribute.#ctor(System.Boolean) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Byte) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Char) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Double) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Int16) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Int32) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Int64) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Object) +System.ComponentModel.DefaultValueAttribute.#ctor(System.SByte) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Single) +System.ComponentModel.DefaultValueAttribute.#ctor(System.String) +System.ComponentModel.DefaultValueAttribute.#ctor(System.Type,System.String) +System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt16) +System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt32) +System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt64) +System.ComponentModel.DefaultValueAttribute.Equals(System.Object) +System.ComponentModel.DefaultValueAttribute.GetHashCode +System.ComponentModel.DefaultValueAttribute.SetValue(System.Object) +System.ComponentModel.DefaultValueAttribute.get_Value +System.ComponentModel.EditorBrowsableAttribute +System.ComponentModel.EditorBrowsableAttribute.#ctor +System.ComponentModel.EditorBrowsableAttribute.#ctor(System.ComponentModel.EditorBrowsableState) +System.ComponentModel.EditorBrowsableAttribute.Equals(System.Object) +System.ComponentModel.EditorBrowsableAttribute.GetHashCode +System.ComponentModel.EditorBrowsableAttribute.get_State +System.ComponentModel.EditorBrowsableState +System.ComponentModel.EditorBrowsableState.Advanced +System.ComponentModel.EditorBrowsableState.Always +System.ComponentModel.EditorBrowsableState.Never +System.Configuration.Assemblies.AssemblyHashAlgorithm +System.Configuration.Assemblies.AssemblyHashAlgorithm.MD5 +System.Configuration.Assemblies.AssemblyHashAlgorithm.None +System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA1 +System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA256 +System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA384 +System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA512 +System.Configuration.Assemblies.AssemblyVersionCompatibility +System.Configuration.Assemblies.AssemblyVersionCompatibility.SameDomain +System.Configuration.Assemblies.AssemblyVersionCompatibility.SameMachine +System.Configuration.Assemblies.AssemblyVersionCompatibility.SameProcess +System.ContextBoundObject +System.ContextBoundObject.#ctor +System.ContextMarshalException +System.ContextMarshalException.#ctor +System.ContextMarshalException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ContextMarshalException.#ctor(System.String) +System.ContextMarshalException.#ctor(System.String,System.Exception) +System.ContextStaticAttribute +System.ContextStaticAttribute.#ctor +System.Convert +System.Convert.ChangeType(System.Object,System.Type) +System.Convert.ChangeType(System.Object,System.Type,System.IFormatProvider) +System.Convert.ChangeType(System.Object,System.TypeCode) +System.Convert.ChangeType(System.Object,System.TypeCode,System.IFormatProvider) +System.Convert.DBNull +System.Convert.FromBase64CharArray(System.Char[],System.Int32,System.Int32) +System.Convert.FromBase64String(System.String) +System.Convert.FromHexString(System.ReadOnlySpan{System.Char}) +System.Convert.FromHexString(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@) +System.Convert.FromHexString(System.String) +System.Convert.FromHexString(System.String,System.Span{System.Byte},System.Int32@,System.Int32@) +System.Convert.GetTypeCode(System.Object) +System.Convert.IsDBNull(System.Object) +System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) +System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Base64FormattingOptions) +System.Convert.ToBase64String(System.Byte[]) +System.Convert.ToBase64String(System.Byte[],System.Base64FormattingOptions) +System.Convert.ToBase64String(System.Byte[],System.Int32,System.Int32) +System.Convert.ToBase64String(System.Byte[],System.Int32,System.Int32,System.Base64FormattingOptions) +System.Convert.ToBase64String(System.ReadOnlySpan{System.Byte},System.Base64FormattingOptions) +System.Convert.ToBoolean(System.Boolean) +System.Convert.ToBoolean(System.Byte) +System.Convert.ToBoolean(System.Char) +System.Convert.ToBoolean(System.DateTime) +System.Convert.ToBoolean(System.Decimal) +System.Convert.ToBoolean(System.Double) +System.Convert.ToBoolean(System.Int16) +System.Convert.ToBoolean(System.Int32) +System.Convert.ToBoolean(System.Int64) +System.Convert.ToBoolean(System.Object) +System.Convert.ToBoolean(System.Object,System.IFormatProvider) +System.Convert.ToBoolean(System.SByte) +System.Convert.ToBoolean(System.Single) +System.Convert.ToBoolean(System.String) +System.Convert.ToBoolean(System.String,System.IFormatProvider) +System.Convert.ToBoolean(System.UInt16) +System.Convert.ToBoolean(System.UInt32) +System.Convert.ToBoolean(System.UInt64) +System.Convert.ToByte(System.Boolean) +System.Convert.ToByte(System.Byte) +System.Convert.ToByte(System.Char) +System.Convert.ToByte(System.DateTime) +System.Convert.ToByte(System.Decimal) +System.Convert.ToByte(System.Double) +System.Convert.ToByte(System.Int16) +System.Convert.ToByte(System.Int32) +System.Convert.ToByte(System.Int64) +System.Convert.ToByte(System.Object) +System.Convert.ToByte(System.Object,System.IFormatProvider) +System.Convert.ToByte(System.SByte) +System.Convert.ToByte(System.Single) +System.Convert.ToByte(System.String) +System.Convert.ToByte(System.String,System.IFormatProvider) +System.Convert.ToByte(System.String,System.Int32) +System.Convert.ToByte(System.UInt16) +System.Convert.ToByte(System.UInt32) +System.Convert.ToByte(System.UInt64) +System.Convert.ToChar(System.Boolean) +System.Convert.ToChar(System.Byte) +System.Convert.ToChar(System.Char) +System.Convert.ToChar(System.DateTime) +System.Convert.ToChar(System.Decimal) +System.Convert.ToChar(System.Double) +System.Convert.ToChar(System.Int16) +System.Convert.ToChar(System.Int32) +System.Convert.ToChar(System.Int64) +System.Convert.ToChar(System.Object) +System.Convert.ToChar(System.Object,System.IFormatProvider) +System.Convert.ToChar(System.SByte) +System.Convert.ToChar(System.Single) +System.Convert.ToChar(System.String) +System.Convert.ToChar(System.String,System.IFormatProvider) +System.Convert.ToChar(System.UInt16) +System.Convert.ToChar(System.UInt32) +System.Convert.ToChar(System.UInt64) +System.Convert.ToDateTime(System.Boolean) +System.Convert.ToDateTime(System.Byte) +System.Convert.ToDateTime(System.Char) +System.Convert.ToDateTime(System.DateTime) +System.Convert.ToDateTime(System.Decimal) +System.Convert.ToDateTime(System.Double) +System.Convert.ToDateTime(System.Int16) +System.Convert.ToDateTime(System.Int32) +System.Convert.ToDateTime(System.Int64) +System.Convert.ToDateTime(System.Object) +System.Convert.ToDateTime(System.Object,System.IFormatProvider) +System.Convert.ToDateTime(System.SByte) +System.Convert.ToDateTime(System.Single) +System.Convert.ToDateTime(System.String) +System.Convert.ToDateTime(System.String,System.IFormatProvider) +System.Convert.ToDateTime(System.UInt16) +System.Convert.ToDateTime(System.UInt32) +System.Convert.ToDateTime(System.UInt64) +System.Convert.ToDecimal(System.Boolean) +System.Convert.ToDecimal(System.Byte) +System.Convert.ToDecimal(System.Char) +System.Convert.ToDecimal(System.DateTime) +System.Convert.ToDecimal(System.Decimal) +System.Convert.ToDecimal(System.Double) +System.Convert.ToDecimal(System.Int16) +System.Convert.ToDecimal(System.Int32) +System.Convert.ToDecimal(System.Int64) +System.Convert.ToDecimal(System.Object) +System.Convert.ToDecimal(System.Object,System.IFormatProvider) +System.Convert.ToDecimal(System.SByte) +System.Convert.ToDecimal(System.Single) +System.Convert.ToDecimal(System.String) +System.Convert.ToDecimal(System.String,System.IFormatProvider) +System.Convert.ToDecimal(System.UInt16) +System.Convert.ToDecimal(System.UInt32) +System.Convert.ToDecimal(System.UInt64) +System.Convert.ToDouble(System.Boolean) +System.Convert.ToDouble(System.Byte) +System.Convert.ToDouble(System.Char) +System.Convert.ToDouble(System.DateTime) +System.Convert.ToDouble(System.Decimal) +System.Convert.ToDouble(System.Double) +System.Convert.ToDouble(System.Int16) +System.Convert.ToDouble(System.Int32) +System.Convert.ToDouble(System.Int64) +System.Convert.ToDouble(System.Object) +System.Convert.ToDouble(System.Object,System.IFormatProvider) +System.Convert.ToDouble(System.SByte) +System.Convert.ToDouble(System.Single) +System.Convert.ToDouble(System.String) +System.Convert.ToDouble(System.String,System.IFormatProvider) +System.Convert.ToDouble(System.UInt16) +System.Convert.ToDouble(System.UInt32) +System.Convert.ToDouble(System.UInt64) +System.Convert.ToHexString(System.Byte[]) +System.Convert.ToHexString(System.Byte[],System.Int32,System.Int32) +System.Convert.ToHexString(System.ReadOnlySpan{System.Byte}) +System.Convert.ToHexStringLower(System.Byte[]) +System.Convert.ToHexStringLower(System.Byte[],System.Int32,System.Int32) +System.Convert.ToHexStringLower(System.ReadOnlySpan{System.Byte}) +System.Convert.ToInt16(System.Boolean) +System.Convert.ToInt16(System.Byte) +System.Convert.ToInt16(System.Char) +System.Convert.ToInt16(System.DateTime) +System.Convert.ToInt16(System.Decimal) +System.Convert.ToInt16(System.Double) +System.Convert.ToInt16(System.Int16) +System.Convert.ToInt16(System.Int32) +System.Convert.ToInt16(System.Int64) +System.Convert.ToInt16(System.Object) +System.Convert.ToInt16(System.Object,System.IFormatProvider) +System.Convert.ToInt16(System.SByte) +System.Convert.ToInt16(System.Single) +System.Convert.ToInt16(System.String) +System.Convert.ToInt16(System.String,System.IFormatProvider) +System.Convert.ToInt16(System.String,System.Int32) +System.Convert.ToInt16(System.UInt16) +System.Convert.ToInt16(System.UInt32) +System.Convert.ToInt16(System.UInt64) +System.Convert.ToInt32(System.Boolean) +System.Convert.ToInt32(System.Byte) +System.Convert.ToInt32(System.Char) +System.Convert.ToInt32(System.DateTime) +System.Convert.ToInt32(System.Decimal) +System.Convert.ToInt32(System.Double) +System.Convert.ToInt32(System.Int16) +System.Convert.ToInt32(System.Int32) +System.Convert.ToInt32(System.Int64) +System.Convert.ToInt32(System.Object) +System.Convert.ToInt32(System.Object,System.IFormatProvider) +System.Convert.ToInt32(System.SByte) +System.Convert.ToInt32(System.Single) +System.Convert.ToInt32(System.String) +System.Convert.ToInt32(System.String,System.IFormatProvider) +System.Convert.ToInt32(System.String,System.Int32) +System.Convert.ToInt32(System.UInt16) +System.Convert.ToInt32(System.UInt32) +System.Convert.ToInt32(System.UInt64) +System.Convert.ToInt64(System.Boolean) +System.Convert.ToInt64(System.Byte) +System.Convert.ToInt64(System.Char) +System.Convert.ToInt64(System.DateTime) +System.Convert.ToInt64(System.Decimal) +System.Convert.ToInt64(System.Double) +System.Convert.ToInt64(System.Int16) +System.Convert.ToInt64(System.Int32) +System.Convert.ToInt64(System.Int64) +System.Convert.ToInt64(System.Object) +System.Convert.ToInt64(System.Object,System.IFormatProvider) +System.Convert.ToInt64(System.SByte) +System.Convert.ToInt64(System.Single) +System.Convert.ToInt64(System.String) +System.Convert.ToInt64(System.String,System.IFormatProvider) +System.Convert.ToInt64(System.String,System.Int32) +System.Convert.ToInt64(System.UInt16) +System.Convert.ToInt64(System.UInt32) +System.Convert.ToInt64(System.UInt64) +System.Convert.ToSByte(System.Boolean) +System.Convert.ToSByte(System.Byte) +System.Convert.ToSByte(System.Char) +System.Convert.ToSByte(System.DateTime) +System.Convert.ToSByte(System.Decimal) +System.Convert.ToSByte(System.Double) +System.Convert.ToSByte(System.Int16) +System.Convert.ToSByte(System.Int32) +System.Convert.ToSByte(System.Int64) +System.Convert.ToSByte(System.Object) +System.Convert.ToSByte(System.Object,System.IFormatProvider) +System.Convert.ToSByte(System.SByte) +System.Convert.ToSByte(System.Single) +System.Convert.ToSByte(System.String) +System.Convert.ToSByte(System.String,System.IFormatProvider) +System.Convert.ToSByte(System.String,System.Int32) +System.Convert.ToSByte(System.UInt16) +System.Convert.ToSByte(System.UInt32) +System.Convert.ToSByte(System.UInt64) +System.Convert.ToSingle(System.Boolean) +System.Convert.ToSingle(System.Byte) +System.Convert.ToSingle(System.Char) +System.Convert.ToSingle(System.DateTime) +System.Convert.ToSingle(System.Decimal) +System.Convert.ToSingle(System.Double) +System.Convert.ToSingle(System.Int16) +System.Convert.ToSingle(System.Int32) +System.Convert.ToSingle(System.Int64) +System.Convert.ToSingle(System.Object) +System.Convert.ToSingle(System.Object,System.IFormatProvider) +System.Convert.ToSingle(System.SByte) +System.Convert.ToSingle(System.Single) +System.Convert.ToSingle(System.String) +System.Convert.ToSingle(System.String,System.IFormatProvider) +System.Convert.ToSingle(System.UInt16) +System.Convert.ToSingle(System.UInt32) +System.Convert.ToSingle(System.UInt64) +System.Convert.ToString(System.Boolean) +System.Convert.ToString(System.Boolean,System.IFormatProvider) +System.Convert.ToString(System.Byte) +System.Convert.ToString(System.Byte,System.IFormatProvider) +System.Convert.ToString(System.Byte,System.Int32) +System.Convert.ToString(System.Char) +System.Convert.ToString(System.Char,System.IFormatProvider) +System.Convert.ToString(System.DateTime) +System.Convert.ToString(System.DateTime,System.IFormatProvider) +System.Convert.ToString(System.Decimal) +System.Convert.ToString(System.Decimal,System.IFormatProvider) +System.Convert.ToString(System.Double) +System.Convert.ToString(System.Double,System.IFormatProvider) +System.Convert.ToString(System.Int16) +System.Convert.ToString(System.Int16,System.IFormatProvider) +System.Convert.ToString(System.Int16,System.Int32) +System.Convert.ToString(System.Int32) +System.Convert.ToString(System.Int32,System.IFormatProvider) +System.Convert.ToString(System.Int32,System.Int32) +System.Convert.ToString(System.Int64) +System.Convert.ToString(System.Int64,System.IFormatProvider) +System.Convert.ToString(System.Int64,System.Int32) +System.Convert.ToString(System.Object) +System.Convert.ToString(System.Object,System.IFormatProvider) +System.Convert.ToString(System.SByte) +System.Convert.ToString(System.SByte,System.IFormatProvider) +System.Convert.ToString(System.Single) +System.Convert.ToString(System.Single,System.IFormatProvider) +System.Convert.ToString(System.String) +System.Convert.ToString(System.String,System.IFormatProvider) +System.Convert.ToString(System.UInt16) +System.Convert.ToString(System.UInt16,System.IFormatProvider) +System.Convert.ToString(System.UInt32) +System.Convert.ToString(System.UInt32,System.IFormatProvider) +System.Convert.ToString(System.UInt64) +System.Convert.ToString(System.UInt64,System.IFormatProvider) +System.Convert.ToUInt16(System.Boolean) +System.Convert.ToUInt16(System.Byte) +System.Convert.ToUInt16(System.Char) +System.Convert.ToUInt16(System.DateTime) +System.Convert.ToUInt16(System.Decimal) +System.Convert.ToUInt16(System.Double) +System.Convert.ToUInt16(System.Int16) +System.Convert.ToUInt16(System.Int32) +System.Convert.ToUInt16(System.Int64) +System.Convert.ToUInt16(System.Object) +System.Convert.ToUInt16(System.Object,System.IFormatProvider) +System.Convert.ToUInt16(System.SByte) +System.Convert.ToUInt16(System.Single) +System.Convert.ToUInt16(System.String) +System.Convert.ToUInt16(System.String,System.IFormatProvider) +System.Convert.ToUInt16(System.String,System.Int32) +System.Convert.ToUInt16(System.UInt16) +System.Convert.ToUInt16(System.UInt32) +System.Convert.ToUInt16(System.UInt64) +System.Convert.ToUInt32(System.Boolean) +System.Convert.ToUInt32(System.Byte) +System.Convert.ToUInt32(System.Char) +System.Convert.ToUInt32(System.DateTime) +System.Convert.ToUInt32(System.Decimal) +System.Convert.ToUInt32(System.Double) +System.Convert.ToUInt32(System.Int16) +System.Convert.ToUInt32(System.Int32) +System.Convert.ToUInt32(System.Int64) +System.Convert.ToUInt32(System.Object) +System.Convert.ToUInt32(System.Object,System.IFormatProvider) +System.Convert.ToUInt32(System.SByte) +System.Convert.ToUInt32(System.Single) +System.Convert.ToUInt32(System.String) +System.Convert.ToUInt32(System.String,System.IFormatProvider) +System.Convert.ToUInt32(System.String,System.Int32) +System.Convert.ToUInt32(System.UInt16) +System.Convert.ToUInt32(System.UInt32) +System.Convert.ToUInt32(System.UInt64) +System.Convert.ToUInt64(System.Boolean) +System.Convert.ToUInt64(System.Byte) +System.Convert.ToUInt64(System.Char) +System.Convert.ToUInt64(System.DateTime) +System.Convert.ToUInt64(System.Decimal) +System.Convert.ToUInt64(System.Double) +System.Convert.ToUInt64(System.Int16) +System.Convert.ToUInt64(System.Int32) +System.Convert.ToUInt64(System.Int64) +System.Convert.ToUInt64(System.Object) +System.Convert.ToUInt64(System.Object,System.IFormatProvider) +System.Convert.ToUInt64(System.SByte) +System.Convert.ToUInt64(System.Single) +System.Convert.ToUInt64(System.String) +System.Convert.ToUInt64(System.String,System.IFormatProvider) +System.Convert.ToUInt64(System.String,System.Int32) +System.Convert.ToUInt64(System.UInt16) +System.Convert.ToUInt64(System.UInt32) +System.Convert.ToUInt64(System.UInt64) +System.Convert.TryFromBase64Chars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +System.Convert.TryFromBase64String(System.String,System.Span{System.Byte},System.Int32@) +System.Convert.TryToBase64Chars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Base64FormattingOptions) +System.Convert.TryToHexString(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Convert.TryToHexStringLower(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Converter`2 +System.Converter`2.#ctor(System.Object,System.IntPtr) +System.Converter`2.BeginInvoke(`0,System.AsyncCallback,System.Object) +System.Converter`2.EndInvoke(System.IAsyncResult) +System.Converter`2.Invoke(`0) +System.DBNull +System.DBNull.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.DBNull.GetTypeCode +System.DBNull.ToString +System.DBNull.ToString(System.IFormatProvider) +System.DBNull.Value +System.DateOnly +System.DateOnly.#ctor(System.Int32,System.Int32,System.Int32) +System.DateOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +System.DateOnly.AddDays(System.Int32) +System.DateOnly.AddMonths(System.Int32) +System.DateOnly.AddYears(System.Int32) +System.DateOnly.CompareTo(System.DateOnly) +System.DateOnly.CompareTo(System.Object) +System.DateOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@) +System.DateOnly.Equals(System.DateOnly) +System.DateOnly.Equals(System.Object) +System.DateOnly.FromDateTime(System.DateTime) +System.DateOnly.FromDayNumber(System.Int32) +System.DateOnly.GetHashCode +System.DateOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateOnly.Parse(System.String) +System.DateOnly.Parse(System.String,System.IFormatProvider) +System.DateOnly.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[]) +System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateOnly.ParseExact(System.String,System.String) +System.DateOnly.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateOnly.ParseExact(System.String,System.String[]) +System.DateOnly.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateOnly.ToDateTime(System.TimeOnly) +System.DateOnly.ToDateTime(System.TimeOnly,System.DateTimeKind) +System.DateOnly.ToLongDateString +System.DateOnly.ToShortDateString +System.DateOnly.ToString +System.DateOnly.ToString(System.IFormatProvider) +System.DateOnly.ToString(System.String) +System.DateOnly.ToString(System.String,System.IFormatProvider) +System.DateOnly.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateOnly.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.DateOnly@) +System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateOnly@) +System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +System.DateOnly.TryParse(System.String,System.DateOnly@) +System.DateOnly.TryParse(System.String,System.IFormatProvider,System.DateOnly@) +System.DateOnly.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.DateOnly@) +System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.DateOnly@) +System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +System.DateOnly.TryParseExact(System.String,System.String,System.DateOnly@) +System.DateOnly.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +System.DateOnly.TryParseExact(System.String,System.String[],System.DateOnly@) +System.DateOnly.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +System.DateOnly.get_Day +System.DateOnly.get_DayNumber +System.DateOnly.get_DayOfWeek +System.DateOnly.get_DayOfYear +System.DateOnly.get_MaxValue +System.DateOnly.get_MinValue +System.DateOnly.get_Month +System.DateOnly.get_Year +System.DateOnly.op_Equality(System.DateOnly,System.DateOnly) +System.DateOnly.op_GreaterThan(System.DateOnly,System.DateOnly) +System.DateOnly.op_GreaterThanOrEqual(System.DateOnly,System.DateOnly) +System.DateOnly.op_Inequality(System.DateOnly,System.DateOnly) +System.DateOnly.op_LessThan(System.DateOnly,System.DateOnly) +System.DateOnly.op_LessThanOrEqual(System.DateOnly,System.DateOnly) +System.DateTime +System.DateTime.#ctor(System.DateOnly,System.TimeOnly) +System.DateTime.#ctor(System.DateOnly,System.TimeOnly,System.DateTimeKind) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind) +System.DateTime.#ctor(System.Int64) +System.DateTime.#ctor(System.Int64,System.DateTimeKind) +System.DateTime.Add(System.TimeSpan) +System.DateTime.AddDays(System.Double) +System.DateTime.AddHours(System.Double) +System.DateTime.AddMicroseconds(System.Double) +System.DateTime.AddMilliseconds(System.Double) +System.DateTime.AddMinutes(System.Double) +System.DateTime.AddMonths(System.Int32) +System.DateTime.AddSeconds(System.Double) +System.DateTime.AddTicks(System.Int64) +System.DateTime.AddYears(System.Int32) +System.DateTime.Compare(System.DateTime,System.DateTime) +System.DateTime.CompareTo(System.DateTime) +System.DateTime.CompareTo(System.Object) +System.DateTime.DaysInMonth(System.Int32,System.Int32) +System.DateTime.Deconstruct(System.DateOnly@,System.TimeOnly@) +System.DateTime.Deconstruct(System.Int32@,System.Int32@,System.Int32@) +System.DateTime.Equals(System.DateTime) +System.DateTime.Equals(System.DateTime,System.DateTime) +System.DateTime.Equals(System.Object) +System.DateTime.FromBinary(System.Int64) +System.DateTime.FromFileTime(System.Int64) +System.DateTime.FromFileTimeUtc(System.Int64) +System.DateTime.FromOADate(System.Double) +System.DateTime.GetDateTimeFormats +System.DateTime.GetDateTimeFormats(System.Char) +System.DateTime.GetDateTimeFormats(System.Char,System.IFormatProvider) +System.DateTime.GetDateTimeFormats(System.IFormatProvider) +System.DateTime.GetHashCode +System.DateTime.GetTypeCode +System.DateTime.IsDaylightSavingTime +System.DateTime.IsLeapYear(System.Int32) +System.DateTime.MaxValue +System.DateTime.MinValue +System.DateTime.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateTime.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTime.Parse(System.String) +System.DateTime.Parse(System.String,System.IFormatProvider) +System.DateTime.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTime.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTime.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTime.ParseExact(System.String,System.String,System.IFormatProvider) +System.DateTime.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTime.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTime.SpecifyKind(System.DateTime,System.DateTimeKind) +System.DateTime.Subtract(System.DateTime) +System.DateTime.Subtract(System.TimeSpan) +System.DateTime.ToBinary +System.DateTime.ToFileTime +System.DateTime.ToFileTimeUtc +System.DateTime.ToLocalTime +System.DateTime.ToLongDateString +System.DateTime.ToLongTimeString +System.DateTime.ToOADate +System.DateTime.ToShortDateString +System.DateTime.ToShortTimeString +System.DateTime.ToString +System.DateTime.ToString(System.IFormatProvider) +System.DateTime.ToString(System.String) +System.DateTime.ToString(System.String,System.IFormatProvider) +System.DateTime.ToUniversalTime +System.DateTime.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateTime.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.DateTime@) +System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateTime@) +System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +System.DateTime.TryParse(System.String,System.DateTime@) +System.DateTime.TryParse(System.String,System.IFormatProvider,System.DateTime@) +System.DateTime.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +System.DateTime.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +System.DateTime.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +System.DateTime.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +System.DateTime.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +System.DateTime.UnixEpoch +System.DateTime.get_Date +System.DateTime.get_Day +System.DateTime.get_DayOfWeek +System.DateTime.get_DayOfYear +System.DateTime.get_Hour +System.DateTime.get_Kind +System.DateTime.get_Microsecond +System.DateTime.get_Millisecond +System.DateTime.get_Minute +System.DateTime.get_Month +System.DateTime.get_Nanosecond +System.DateTime.get_Now +System.DateTime.get_Second +System.DateTime.get_Ticks +System.DateTime.get_TimeOfDay +System.DateTime.get_Today +System.DateTime.get_UtcNow +System.DateTime.get_Year +System.DateTime.op_Addition(System.DateTime,System.TimeSpan) +System.DateTime.op_Equality(System.DateTime,System.DateTime) +System.DateTime.op_GreaterThan(System.DateTime,System.DateTime) +System.DateTime.op_GreaterThanOrEqual(System.DateTime,System.DateTime) +System.DateTime.op_Inequality(System.DateTime,System.DateTime) +System.DateTime.op_LessThan(System.DateTime,System.DateTime) +System.DateTime.op_LessThanOrEqual(System.DateTime,System.DateTime) +System.DateTime.op_Subtraction(System.DateTime,System.DateTime) +System.DateTime.op_Subtraction(System.DateTime,System.TimeSpan) +System.DateTimeKind +System.DateTimeKind.Local +System.DateTimeKind.Unspecified +System.DateTimeKind.Utc +System.DateTimeOffset +System.DateTimeOffset.#ctor(System.DateOnly,System.TimeOnly,System.TimeSpan) +System.DateTimeOffset.#ctor(System.DateTime) +System.DateTimeOffset.#ctor(System.DateTime,System.TimeSpan) +System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan) +System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan) +System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) +System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) +System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) +System.DateTimeOffset.#ctor(System.Int64,System.TimeSpan) +System.DateTimeOffset.Add(System.TimeSpan) +System.DateTimeOffset.AddDays(System.Double) +System.DateTimeOffset.AddHours(System.Double) +System.DateTimeOffset.AddMicroseconds(System.Double) +System.DateTimeOffset.AddMilliseconds(System.Double) +System.DateTimeOffset.AddMinutes(System.Double) +System.DateTimeOffset.AddMonths(System.Int32) +System.DateTimeOffset.AddSeconds(System.Double) +System.DateTimeOffset.AddTicks(System.Int64) +System.DateTimeOffset.AddYears(System.Int32) +System.DateTimeOffset.Compare(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.CompareTo(System.DateTimeOffset) +System.DateTimeOffset.Deconstruct(System.DateOnly@,System.TimeOnly@,System.TimeSpan@) +System.DateTimeOffset.Equals(System.DateTimeOffset) +System.DateTimeOffset.Equals(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.Equals(System.Object) +System.DateTimeOffset.EqualsExact(System.DateTimeOffset) +System.DateTimeOffset.FromFileTime(System.Int64) +System.DateTimeOffset.FromUnixTimeMilliseconds(System.Int64) +System.DateTimeOffset.FromUnixTimeSeconds(System.Int64) +System.DateTimeOffset.GetHashCode +System.DateTimeOffset.MaxValue +System.DateTimeOffset.MinValue +System.DateTimeOffset.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateTimeOffset.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTimeOffset.Parse(System.String) +System.DateTimeOffset.Parse(System.String,System.IFormatProvider) +System.DateTimeOffset.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTimeOffset.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTimeOffset.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTimeOffset.ParseExact(System.String,System.String,System.IFormatProvider) +System.DateTimeOffset.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTimeOffset.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.DateTimeOffset.Subtract(System.DateTimeOffset) +System.DateTimeOffset.Subtract(System.TimeSpan) +System.DateTimeOffset.ToFileTime +System.DateTimeOffset.ToLocalTime +System.DateTimeOffset.ToOffset(System.TimeSpan) +System.DateTimeOffset.ToString +System.DateTimeOffset.ToString(System.IFormatProvider) +System.DateTimeOffset.ToString(System.String) +System.DateTimeOffset.ToString(System.String,System.IFormatProvider) +System.DateTimeOffset.ToUniversalTime +System.DateTimeOffset.ToUnixTimeMilliseconds +System.DateTimeOffset.ToUnixTimeSeconds +System.DateTimeOffset.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateTimeOffset.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.DateTimeOffset@) +System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateTimeOffset@) +System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +System.DateTimeOffset.TryParse(System.String,System.DateTimeOffset@) +System.DateTimeOffset.TryParse(System.String,System.IFormatProvider,System.DateTimeOffset@) +System.DateTimeOffset.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +System.DateTimeOffset.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +System.DateTimeOffset.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +System.DateTimeOffset.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +System.DateTimeOffset.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +System.DateTimeOffset.UnixEpoch +System.DateTimeOffset.get_Date +System.DateTimeOffset.get_DateTime +System.DateTimeOffset.get_Day +System.DateTimeOffset.get_DayOfWeek +System.DateTimeOffset.get_DayOfYear +System.DateTimeOffset.get_Hour +System.DateTimeOffset.get_LocalDateTime +System.DateTimeOffset.get_Microsecond +System.DateTimeOffset.get_Millisecond +System.DateTimeOffset.get_Minute +System.DateTimeOffset.get_Month +System.DateTimeOffset.get_Nanosecond +System.DateTimeOffset.get_Now +System.DateTimeOffset.get_Offset +System.DateTimeOffset.get_Second +System.DateTimeOffset.get_Ticks +System.DateTimeOffset.get_TimeOfDay +System.DateTimeOffset.get_TotalOffsetMinutes +System.DateTimeOffset.get_UtcDateTime +System.DateTimeOffset.get_UtcNow +System.DateTimeOffset.get_UtcTicks +System.DateTimeOffset.get_Year +System.DateTimeOffset.op_Addition(System.DateTimeOffset,System.TimeSpan) +System.DateTimeOffset.op_Equality(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_GreaterThan(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_GreaterThanOrEqual(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_Implicit(System.DateTime)~System.DateTimeOffset +System.DateTimeOffset.op_Inequality(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_LessThan(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_LessThanOrEqual(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_Subtraction(System.DateTimeOffset,System.DateTimeOffset) +System.DateTimeOffset.op_Subtraction(System.DateTimeOffset,System.TimeSpan) +System.DayOfWeek +System.DayOfWeek.Friday +System.DayOfWeek.Monday +System.DayOfWeek.Saturday +System.DayOfWeek.Sunday +System.DayOfWeek.Thursday +System.DayOfWeek.Tuesday +System.DayOfWeek.Wednesday +System.Decimal +System.Decimal.#ctor(System.Double) +System.Decimal.#ctor(System.Int32) +System.Decimal.#ctor(System.Int32,System.Int32,System.Int32,System.Boolean,System.Byte) +System.Decimal.#ctor(System.Int32[]) +System.Decimal.#ctor(System.Int64) +System.Decimal.#ctor(System.ReadOnlySpan{System.Int32}) +System.Decimal.#ctor(System.Single) +System.Decimal.#ctor(System.UInt32) +System.Decimal.#ctor(System.UInt64) +System.Decimal.Abs(System.Decimal) +System.Decimal.Add(System.Decimal,System.Decimal) +System.Decimal.Ceiling(System.Decimal) +System.Decimal.Clamp(System.Decimal,System.Decimal,System.Decimal) +System.Decimal.Compare(System.Decimal,System.Decimal) +System.Decimal.CompareTo(System.Decimal) +System.Decimal.CompareTo(System.Object) +System.Decimal.ConvertToIntegerNative``1(System.Decimal) +System.Decimal.ConvertToInteger``1(System.Decimal) +System.Decimal.CopySign(System.Decimal,System.Decimal) +System.Decimal.CreateChecked``1(``0) +System.Decimal.CreateSaturating``1(``0) +System.Decimal.CreateTruncating``1(``0) +System.Decimal.Divide(System.Decimal,System.Decimal) +System.Decimal.Equals(System.Decimal) +System.Decimal.Equals(System.Decimal,System.Decimal) +System.Decimal.Equals(System.Object) +System.Decimal.Floor(System.Decimal) +System.Decimal.FromOACurrency(System.Int64) +System.Decimal.GetBits(System.Decimal) +System.Decimal.GetBits(System.Decimal,System.Span{System.Int32}) +System.Decimal.GetHashCode +System.Decimal.GetTypeCode +System.Decimal.IsCanonical(System.Decimal) +System.Decimal.IsEvenInteger(System.Decimal) +System.Decimal.IsInteger(System.Decimal) +System.Decimal.IsNegative(System.Decimal) +System.Decimal.IsOddInteger(System.Decimal) +System.Decimal.IsPositive(System.Decimal) +System.Decimal.Max(System.Decimal,System.Decimal) +System.Decimal.MaxMagnitude(System.Decimal,System.Decimal) +System.Decimal.MaxValue +System.Decimal.Min(System.Decimal,System.Decimal) +System.Decimal.MinMagnitude(System.Decimal,System.Decimal) +System.Decimal.MinValue +System.Decimal.MinusOne +System.Decimal.Multiply(System.Decimal,System.Decimal) +System.Decimal.Negate(System.Decimal) +System.Decimal.One +System.Decimal.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Decimal.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Decimal.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Decimal.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Decimal.Parse(System.String) +System.Decimal.Parse(System.String,System.Globalization.NumberStyles) +System.Decimal.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Decimal.Parse(System.String,System.IFormatProvider) +System.Decimal.Remainder(System.Decimal,System.Decimal) +System.Decimal.Round(System.Decimal) +System.Decimal.Round(System.Decimal,System.Int32) +System.Decimal.Round(System.Decimal,System.Int32,System.MidpointRounding) +System.Decimal.Round(System.Decimal,System.MidpointRounding) +System.Decimal.Sign(System.Decimal) +System.Decimal.Subtract(System.Decimal,System.Decimal) +System.Decimal.ToByte(System.Decimal) +System.Decimal.ToDouble(System.Decimal) +System.Decimal.ToInt16(System.Decimal) +System.Decimal.ToInt32(System.Decimal) +System.Decimal.ToInt64(System.Decimal) +System.Decimal.ToOACurrency(System.Decimal) +System.Decimal.ToSByte(System.Decimal) +System.Decimal.ToSingle(System.Decimal) +System.Decimal.ToString +System.Decimal.ToString(System.IFormatProvider) +System.Decimal.ToString(System.String) +System.Decimal.ToString(System.String,System.IFormatProvider) +System.Decimal.ToUInt16(System.Decimal) +System.Decimal.ToUInt32(System.Decimal) +System.Decimal.ToUInt64(System.Decimal) +System.Decimal.Truncate(System.Decimal) +System.Decimal.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Decimal.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Decimal.TryGetBits(System.Decimal,System.Span{System.Int32},System.Int32@) +System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.Decimal@) +System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) +System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Decimal@) +System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.Decimal@) +System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) +System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Decimal@) +System.Decimal.TryParse(System.String,System.Decimal@) +System.Decimal.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) +System.Decimal.TryParse(System.String,System.IFormatProvider,System.Decimal@) +System.Decimal.Zero +System.Decimal.get_Scale +System.Decimal.op_Addition(System.Decimal,System.Decimal) +System.Decimal.op_Decrement(System.Decimal) +System.Decimal.op_Division(System.Decimal,System.Decimal) +System.Decimal.op_Equality(System.Decimal,System.Decimal) +System.Decimal.op_Explicit(System.Decimal)~System.Byte +System.Decimal.op_Explicit(System.Decimal)~System.Char +System.Decimal.op_Explicit(System.Decimal)~System.Double +System.Decimal.op_Explicit(System.Decimal)~System.Int16 +System.Decimal.op_Explicit(System.Decimal)~System.Int32 +System.Decimal.op_Explicit(System.Decimal)~System.Int64 +System.Decimal.op_Explicit(System.Decimal)~System.SByte +System.Decimal.op_Explicit(System.Decimal)~System.Single +System.Decimal.op_Explicit(System.Decimal)~System.UInt16 +System.Decimal.op_Explicit(System.Decimal)~System.UInt32 +System.Decimal.op_Explicit(System.Decimal)~System.UInt64 +System.Decimal.op_Explicit(System.Double)~System.Decimal +System.Decimal.op_Explicit(System.Single)~System.Decimal +System.Decimal.op_GreaterThan(System.Decimal,System.Decimal) +System.Decimal.op_GreaterThanOrEqual(System.Decimal,System.Decimal) +System.Decimal.op_Implicit(System.Byte)~System.Decimal +System.Decimal.op_Implicit(System.Char)~System.Decimal +System.Decimal.op_Implicit(System.Int16)~System.Decimal +System.Decimal.op_Implicit(System.Int32)~System.Decimal +System.Decimal.op_Implicit(System.Int64)~System.Decimal +System.Decimal.op_Implicit(System.SByte)~System.Decimal +System.Decimal.op_Implicit(System.UInt16)~System.Decimal +System.Decimal.op_Implicit(System.UInt32)~System.Decimal +System.Decimal.op_Implicit(System.UInt64)~System.Decimal +System.Decimal.op_Increment(System.Decimal) +System.Decimal.op_Inequality(System.Decimal,System.Decimal) +System.Decimal.op_LessThan(System.Decimal,System.Decimal) +System.Decimal.op_LessThanOrEqual(System.Decimal,System.Decimal) +System.Decimal.op_Modulus(System.Decimal,System.Decimal) +System.Decimal.op_Multiply(System.Decimal,System.Decimal) +System.Decimal.op_Subtraction(System.Decimal,System.Decimal) +System.Decimal.op_UnaryNegation(System.Decimal) +System.Decimal.op_UnaryPlus(System.Decimal) +System.Delegate +System.Delegate.#ctor(System.Object,System.String) +System.Delegate.#ctor(System.Type,System.String) +System.Delegate.Clone +System.Delegate.Combine(System.Delegate,System.Delegate) +System.Delegate.Combine(System.Delegate[]) +System.Delegate.Combine(System.ReadOnlySpan{System.Delegate}) +System.Delegate.CombineImpl(System.Delegate) +System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo) +System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boolean) +System.Delegate.CreateDelegate(System.Type,System.Object,System.String) +System.Delegate.CreateDelegate(System.Type,System.Object,System.String,System.Boolean) +System.Delegate.CreateDelegate(System.Type,System.Object,System.String,System.Boolean,System.Boolean) +System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo) +System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo,System.Boolean) +System.Delegate.CreateDelegate(System.Type,System.Type,System.String) +System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean) +System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean,System.Boolean) +System.Delegate.DynamicInvoke(System.Object[]) +System.Delegate.DynamicInvokeImpl(System.Object[]) +System.Delegate.EnumerateInvocationList``1(``0) +System.Delegate.Equals(System.Object) +System.Delegate.GetHashCode +System.Delegate.GetInvocationList +System.Delegate.GetMethodImpl +System.Delegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Delegate.InvocationListEnumerator`1 +System.Delegate.InvocationListEnumerator`1.GetEnumerator +System.Delegate.InvocationListEnumerator`1.MoveNext +System.Delegate.InvocationListEnumerator`1.get_Current +System.Delegate.Remove(System.Delegate,System.Delegate) +System.Delegate.RemoveAll(System.Delegate,System.Delegate) +System.Delegate.RemoveImpl(System.Delegate) +System.Delegate.get_HasSingleTarget +System.Delegate.get_Method +System.Delegate.get_Target +System.Delegate.op_Equality(System.Delegate,System.Delegate) +System.Delegate.op_Inequality(System.Delegate,System.Delegate) +System.Diagnostics.CodeAnalysis.AllowNullAttribute +System.Diagnostics.CodeAnalysis.AllowNullAttribute.#ctor +System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute +System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.#ctor +System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.get_Max +System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.get_Min +System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.set_Max(System.Object) +System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.set_Min(System.Object) +System.Diagnostics.CodeAnalysis.DisallowNullAttribute +System.Diagnostics.CodeAnalysis.DisallowNullAttribute.#ctor +System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute +System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute.#ctor +System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute +System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.#ctor(System.Boolean) +System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.get_ParameterValue +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,System.String,System.String) +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,System.Type) +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String,System.String,System.String) +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String,System.Type) +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_AssemblyName +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_Condition +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_MemberSignature +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_MemberTypes +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_Type +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_TypeName +System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.set_Condition(System.String) +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.None +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes) +System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.get_MemberTypes +System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute +System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.#ctor +System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.get_Justification +System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.set_Justification(System.String) +System.Diagnostics.CodeAnalysis.ExperimentalAttribute +System.Diagnostics.CodeAnalysis.ExperimentalAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_DiagnosticId +System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_UrlFormat +System.Diagnostics.CodeAnalysis.ExperimentalAttribute.set_UrlFormat(System.String) +System.Diagnostics.CodeAnalysis.FeatureGuardAttribute +System.Diagnostics.CodeAnalysis.FeatureGuardAttribute.#ctor(System.Type) +System.Diagnostics.CodeAnalysis.FeatureGuardAttribute.get_FeatureType +System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute +System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute.get_SwitchName +System.Diagnostics.CodeAnalysis.MaybeNullAttribute +System.Diagnostics.CodeAnalysis.MaybeNullAttribute.#ctor +System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute +System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.#ctor(System.Boolean) +System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.get_ReturnValue +System.Diagnostics.CodeAnalysis.MemberNotNullAttribute +System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String[]) +System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.get_Members +System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute +System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String) +System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String[]) +System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.get_Members +System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.get_ReturnValue +System.Diagnostics.CodeAnalysis.NotNullAttribute +System.Diagnostics.CodeAnalysis.NotNullAttribute.#ctor +System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute +System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.get_ParameterName +System.Diagnostics.CodeAnalysis.NotNullWhenAttribute +System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.#ctor(System.Boolean) +System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.get_ReturnValue +System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute +System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.#ctor +System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.get_Message +System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.get_Url +System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.set_Url(System.String) +System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute +System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.get_Message +System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.get_Url +System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.set_Url(System.String) +System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute +System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.get_Message +System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.get_Url +System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.set_Url(System.String) +System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute +System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute.#ctor +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.#ctor(System.String) +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.#ctor(System.String,System.Object[]) +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.CompositeFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.DateOnlyFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.DateTimeFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.EnumFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.GuidFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Json +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.NumericFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.TimeOnlyFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.TimeSpanFormat +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Uri +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Xml +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.get_Arguments +System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.get_Syntax +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.#ctor(System.String,System.String) +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Category +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_CheckId +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Justification +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_MessageId +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Scope +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Target +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Justification(System.String) +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_MessageId(System.String) +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Scope(System.String) +System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Target(System.String) +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.#ctor(System.String,System.String) +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Category +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_CheckId +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Justification +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_MessageId +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Scope +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Target +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Justification(System.String) +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_MessageId(System.String) +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Scope(System.String) +System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Target(System.String) +System.Diagnostics.CodeAnalysis.UnscopedRefAttribute +System.Diagnostics.CodeAnalysis.UnscopedRefAttribute.#ctor +System.Diagnostics.ConditionalAttribute +System.Diagnostics.ConditionalAttribute.#ctor(System.String) +System.Diagnostics.ConditionalAttribute.get_ConditionString +System.Diagnostics.Debug +System.Diagnostics.Debug.Assert(System.Boolean) +System.Diagnostics.Debug.Assert(System.Boolean,System.Diagnostics.Debug.AssertInterpolatedStringHandler@) +System.Diagnostics.Debug.Assert(System.Boolean,System.Diagnostics.Debug.AssertInterpolatedStringHandler@,System.Diagnostics.Debug.AssertInterpolatedStringHandler@) +System.Diagnostics.Debug.Assert(System.Boolean,System.String) +System.Diagnostics.Debug.Assert(System.Boolean,System.String,System.String) +System.Diagnostics.Debug.Assert(System.Boolean,System.String,System.String,System.Object[]) +System.Diagnostics.Debug.Close +System.Diagnostics.Debug.Fail(System.String) +System.Diagnostics.Debug.Fail(System.String,System.String) +System.Diagnostics.Debug.Flush +System.Diagnostics.Debug.Indent +System.Diagnostics.Debug.Print(System.String) +System.Diagnostics.Debug.Print(System.String,System.Object[]) +System.Diagnostics.Debug.Unindent +System.Diagnostics.Debug.Write(System.Object) +System.Diagnostics.Debug.Write(System.Object,System.String) +System.Diagnostics.Debug.Write(System.String) +System.Diagnostics.Debug.Write(System.String,System.String) +System.Diagnostics.Debug.WriteIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@) +System.Diagnostics.Debug.WriteIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@,System.String) +System.Diagnostics.Debug.WriteIf(System.Boolean,System.Object) +System.Diagnostics.Debug.WriteIf(System.Boolean,System.Object,System.String) +System.Diagnostics.Debug.WriteIf(System.Boolean,System.String) +System.Diagnostics.Debug.WriteIf(System.Boolean,System.String,System.String) +System.Diagnostics.Debug.WriteLine(System.Object) +System.Diagnostics.Debug.WriteLine(System.Object,System.String) +System.Diagnostics.Debug.WriteLine(System.String) +System.Diagnostics.Debug.WriteLine(System.String,System.Object[]) +System.Diagnostics.Debug.WriteLine(System.String,System.String) +System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@) +System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@,System.String) +System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Object) +System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Object,System.String) +System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.String) +System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.String,System.String) +System.Diagnostics.Debug.get_AutoFlush +System.Diagnostics.Debug.get_IndentLevel +System.Diagnostics.Debug.get_IndentSize +System.Diagnostics.Debug.set_AutoFlush(System.Boolean) +System.Diagnostics.Debug.set_IndentLevel(System.Int32) +System.Diagnostics.Debug.set_IndentSize(System.Int32) +System.Diagnostics.DebuggableAttribute +System.Diagnostics.DebuggableAttribute.#ctor(System.Boolean,System.Boolean) +System.Diagnostics.DebuggableAttribute.#ctor(System.Diagnostics.DebuggableAttribute.DebuggingModes) +System.Diagnostics.DebuggableAttribute.DebuggingModes +System.Diagnostics.DebuggableAttribute.DebuggingModes.Default +System.Diagnostics.DebuggableAttribute.DebuggingModes.DisableOptimizations +System.Diagnostics.DebuggableAttribute.DebuggingModes.EnableEditAndContinue +System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints +System.Diagnostics.DebuggableAttribute.DebuggingModes.None +System.Diagnostics.DebuggableAttribute.get_DebuggingFlags +System.Diagnostics.DebuggableAttribute.get_IsJITOptimizerDisabled +System.Diagnostics.DebuggableAttribute.get_IsJITTrackingEnabled +System.Diagnostics.DebuggerBrowsableAttribute +System.Diagnostics.DebuggerBrowsableAttribute.#ctor(System.Diagnostics.DebuggerBrowsableState) +System.Diagnostics.DebuggerBrowsableAttribute.get_State +System.Diagnostics.DebuggerBrowsableState +System.Diagnostics.DebuggerBrowsableState.Collapsed +System.Diagnostics.DebuggerBrowsableState.Never +System.Diagnostics.DebuggerBrowsableState.RootHidden +System.Diagnostics.DebuggerDisableUserUnhandledExceptionsAttribute +System.Diagnostics.DebuggerDisableUserUnhandledExceptionsAttribute.#ctor +System.Diagnostics.DebuggerDisplayAttribute +System.Diagnostics.DebuggerDisplayAttribute.#ctor(System.String) +System.Diagnostics.DebuggerDisplayAttribute.get_Name +System.Diagnostics.DebuggerDisplayAttribute.get_Target +System.Diagnostics.DebuggerDisplayAttribute.get_TargetTypeName +System.Diagnostics.DebuggerDisplayAttribute.get_Type +System.Diagnostics.DebuggerDisplayAttribute.get_Value +System.Diagnostics.DebuggerDisplayAttribute.set_Name(System.String) +System.Diagnostics.DebuggerDisplayAttribute.set_Target(System.Type) +System.Diagnostics.DebuggerDisplayAttribute.set_TargetTypeName(System.String) +System.Diagnostics.DebuggerDisplayAttribute.set_Type(System.String) +System.Diagnostics.DebuggerHiddenAttribute +System.Diagnostics.DebuggerHiddenAttribute.#ctor +System.Diagnostics.DebuggerNonUserCodeAttribute +System.Diagnostics.DebuggerNonUserCodeAttribute.#ctor +System.Diagnostics.DebuggerStepThroughAttribute +System.Diagnostics.DebuggerStepThroughAttribute.#ctor +System.Diagnostics.DebuggerStepperBoundaryAttribute +System.Diagnostics.DebuggerStepperBoundaryAttribute.#ctor +System.Diagnostics.DebuggerTypeProxyAttribute +System.Diagnostics.DebuggerTypeProxyAttribute.#ctor(System.String) +System.Diagnostics.DebuggerTypeProxyAttribute.#ctor(System.Type) +System.Diagnostics.DebuggerTypeProxyAttribute.get_ProxyTypeName +System.Diagnostics.DebuggerTypeProxyAttribute.get_Target +System.Diagnostics.DebuggerTypeProxyAttribute.get_TargetTypeName +System.Diagnostics.DebuggerTypeProxyAttribute.set_Target(System.Type) +System.Diagnostics.DebuggerTypeProxyAttribute.set_TargetTypeName(System.String) +System.Diagnostics.DebuggerVisualizerAttribute +System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String) +System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String,System.String) +System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String,System.Type) +System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type) +System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type,System.String) +System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type,System.Type) +System.Diagnostics.DebuggerVisualizerAttribute.get_Description +System.Diagnostics.DebuggerVisualizerAttribute.get_Target +System.Diagnostics.DebuggerVisualizerAttribute.get_TargetTypeName +System.Diagnostics.DebuggerVisualizerAttribute.get_VisualizerObjectSourceTypeName +System.Diagnostics.DebuggerVisualizerAttribute.get_VisualizerTypeName +System.Diagnostics.DebuggerVisualizerAttribute.set_Description(System.String) +System.Diagnostics.DebuggerVisualizerAttribute.set_Target(System.Type) +System.Diagnostics.DebuggerVisualizerAttribute.set_TargetTypeName(System.String) +System.Diagnostics.StackTraceHiddenAttribute +System.Diagnostics.StackTraceHiddenAttribute.#ctor +System.Diagnostics.Stopwatch +System.Diagnostics.Stopwatch.#ctor +System.Diagnostics.Stopwatch.Frequency +System.Diagnostics.Stopwatch.GetElapsedTime(System.Int64) +System.Diagnostics.Stopwatch.GetElapsedTime(System.Int64,System.Int64) +System.Diagnostics.Stopwatch.GetTimestamp +System.Diagnostics.Stopwatch.IsHighResolution +System.Diagnostics.Stopwatch.Reset +System.Diagnostics.Stopwatch.Restart +System.Diagnostics.Stopwatch.Start +System.Diagnostics.Stopwatch.StartNew +System.Diagnostics.Stopwatch.Stop +System.Diagnostics.Stopwatch.ToString +System.Diagnostics.Stopwatch.get_Elapsed +System.Diagnostics.Stopwatch.get_ElapsedMilliseconds +System.Diagnostics.Stopwatch.get_ElapsedTicks +System.Diagnostics.Stopwatch.get_IsRunning +System.Diagnostics.UnreachableException +System.Diagnostics.UnreachableException.#ctor +System.Diagnostics.UnreachableException.#ctor(System.String) +System.Diagnostics.UnreachableException.#ctor(System.String,System.Exception) +System.DivideByZeroException +System.DivideByZeroException.#ctor +System.DivideByZeroException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.DivideByZeroException.#ctor(System.String) +System.DivideByZeroException.#ctor(System.String,System.Exception) +System.Double +System.Double.Abs(System.Double) +System.Double.Acos(System.Double) +System.Double.AcosPi(System.Double) +System.Double.Acosh(System.Double) +System.Double.Asin(System.Double) +System.Double.AsinPi(System.Double) +System.Double.Asinh(System.Double) +System.Double.Atan(System.Double) +System.Double.Atan2(System.Double,System.Double) +System.Double.Atan2Pi(System.Double,System.Double) +System.Double.AtanPi(System.Double) +System.Double.Atanh(System.Double) +System.Double.BitDecrement(System.Double) +System.Double.BitIncrement(System.Double) +System.Double.Cbrt(System.Double) +System.Double.Ceiling(System.Double) +System.Double.Clamp(System.Double,System.Double,System.Double) +System.Double.CompareTo(System.Double) +System.Double.CompareTo(System.Object) +System.Double.ConvertToIntegerNative``1(System.Double) +System.Double.ConvertToInteger``1(System.Double) +System.Double.CopySign(System.Double,System.Double) +System.Double.Cos(System.Double) +System.Double.CosPi(System.Double) +System.Double.Cosh(System.Double) +System.Double.CreateChecked``1(``0) +System.Double.CreateSaturating``1(``0) +System.Double.CreateTruncating``1(``0) +System.Double.DegreesToRadians(System.Double) +System.Double.E +System.Double.Epsilon +System.Double.Equals(System.Double) +System.Double.Equals(System.Object) +System.Double.Exp(System.Double) +System.Double.Exp10(System.Double) +System.Double.Exp10M1(System.Double) +System.Double.Exp2(System.Double) +System.Double.Exp2M1(System.Double) +System.Double.ExpM1(System.Double) +System.Double.Floor(System.Double) +System.Double.FusedMultiplyAdd(System.Double,System.Double,System.Double) +System.Double.GetHashCode +System.Double.GetTypeCode +System.Double.Hypot(System.Double,System.Double) +System.Double.ILogB(System.Double) +System.Double.Ieee754Remainder(System.Double,System.Double) +System.Double.IsEvenInteger(System.Double) +System.Double.IsFinite(System.Double) +System.Double.IsInfinity(System.Double) +System.Double.IsInteger(System.Double) +System.Double.IsNaN(System.Double) +System.Double.IsNegative(System.Double) +System.Double.IsNegativeInfinity(System.Double) +System.Double.IsNormal(System.Double) +System.Double.IsOddInteger(System.Double) +System.Double.IsPositive(System.Double) +System.Double.IsPositiveInfinity(System.Double) +System.Double.IsPow2(System.Double) +System.Double.IsRealNumber(System.Double) +System.Double.IsSubnormal(System.Double) +System.Double.Lerp(System.Double,System.Double,System.Double) +System.Double.Log(System.Double) +System.Double.Log(System.Double,System.Double) +System.Double.Log10(System.Double) +System.Double.Log10P1(System.Double) +System.Double.Log2(System.Double) +System.Double.Log2P1(System.Double) +System.Double.LogP1(System.Double) +System.Double.Max(System.Double,System.Double) +System.Double.MaxMagnitude(System.Double,System.Double) +System.Double.MaxMagnitudeNumber(System.Double,System.Double) +System.Double.MaxNumber(System.Double,System.Double) +System.Double.MaxValue +System.Double.Min(System.Double,System.Double) +System.Double.MinMagnitude(System.Double,System.Double) +System.Double.MinMagnitudeNumber(System.Double,System.Double) +System.Double.MinNumber(System.Double,System.Double) +System.Double.MinValue +System.Double.MultiplyAddEstimate(System.Double,System.Double,System.Double) +System.Double.NaN +System.Double.NegativeInfinity +System.Double.NegativeZero +System.Double.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Double.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Double.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Double.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Double.Parse(System.String) +System.Double.Parse(System.String,System.Globalization.NumberStyles) +System.Double.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Double.Parse(System.String,System.IFormatProvider) +System.Double.Pi +System.Double.PositiveInfinity +System.Double.Pow(System.Double,System.Double) +System.Double.RadiansToDegrees(System.Double) +System.Double.ReciprocalEstimate(System.Double) +System.Double.ReciprocalSqrtEstimate(System.Double) +System.Double.RootN(System.Double,System.Int32) +System.Double.Round(System.Double) +System.Double.Round(System.Double,System.Int32) +System.Double.Round(System.Double,System.Int32,System.MidpointRounding) +System.Double.Round(System.Double,System.MidpointRounding) +System.Double.ScaleB(System.Double,System.Int32) +System.Double.Sign(System.Double) +System.Double.Sin(System.Double) +System.Double.SinCos(System.Double) +System.Double.SinCosPi(System.Double) +System.Double.SinPi(System.Double) +System.Double.Sinh(System.Double) +System.Double.Sqrt(System.Double) +System.Double.Tan(System.Double) +System.Double.TanPi(System.Double) +System.Double.Tanh(System.Double) +System.Double.Tau +System.Double.ToString +System.Double.ToString(System.IFormatProvider) +System.Double.ToString(System.String) +System.Double.ToString(System.String,System.IFormatProvider) +System.Double.Truncate(System.Double) +System.Double.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Double.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.Double@) +System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) +System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Double@) +System.Double.TryParse(System.ReadOnlySpan{System.Char},System.Double@) +System.Double.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) +System.Double.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Double@) +System.Double.TryParse(System.String,System.Double@) +System.Double.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) +System.Double.TryParse(System.String,System.IFormatProvider,System.Double@) +System.Double.op_Equality(System.Double,System.Double) +System.Double.op_GreaterThan(System.Double,System.Double) +System.Double.op_GreaterThanOrEqual(System.Double,System.Double) +System.Double.op_Inequality(System.Double,System.Double) +System.Double.op_LessThan(System.Double,System.Double) +System.Double.op_LessThanOrEqual(System.Double,System.Double) +System.DuplicateWaitObjectException +System.DuplicateWaitObjectException.#ctor +System.DuplicateWaitObjectException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.DuplicateWaitObjectException.#ctor(System.String) +System.DuplicateWaitObjectException.#ctor(System.String,System.Exception) +System.DuplicateWaitObjectException.#ctor(System.String,System.String) +System.EntryPointNotFoundException +System.EntryPointNotFoundException.#ctor +System.EntryPointNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.EntryPointNotFoundException.#ctor(System.String) +System.EntryPointNotFoundException.#ctor(System.String,System.Exception) +System.Enum +System.Enum.#ctor +System.Enum.CompareTo(System.Object) +System.Enum.Equals(System.Object) +System.Enum.Format(System.Type,System.Object,System.String) +System.Enum.GetHashCode +System.Enum.GetName(System.Type,System.Object) +System.Enum.GetName``1(``0) +System.Enum.GetNames(System.Type) +System.Enum.GetNames``1 +System.Enum.GetTypeCode +System.Enum.GetUnderlyingType(System.Type) +System.Enum.GetValues(System.Type) +System.Enum.GetValuesAsUnderlyingType(System.Type) +System.Enum.GetValuesAsUnderlyingType``1 +System.Enum.GetValues``1 +System.Enum.HasFlag(System.Enum) +System.Enum.IsDefined(System.Type,System.Object) +System.Enum.IsDefined``1(``0) +System.Enum.Parse(System.Type,System.ReadOnlySpan{System.Char}) +System.Enum.Parse(System.Type,System.ReadOnlySpan{System.Char},System.Boolean) +System.Enum.Parse(System.Type,System.String) +System.Enum.Parse(System.Type,System.String,System.Boolean) +System.Enum.Parse``1(System.ReadOnlySpan{System.Char}) +System.Enum.Parse``1(System.ReadOnlySpan{System.Char},System.Boolean) +System.Enum.Parse``1(System.String) +System.Enum.Parse``1(System.String,System.Boolean) +System.Enum.ToObject(System.Type,System.Byte) +System.Enum.ToObject(System.Type,System.Int16) +System.Enum.ToObject(System.Type,System.Int32) +System.Enum.ToObject(System.Type,System.Int64) +System.Enum.ToObject(System.Type,System.Object) +System.Enum.ToObject(System.Type,System.SByte) +System.Enum.ToObject(System.Type,System.UInt16) +System.Enum.ToObject(System.Type,System.UInt32) +System.Enum.ToObject(System.Type,System.UInt64) +System.Enum.ToString +System.Enum.ToString(System.IFormatProvider) +System.Enum.ToString(System.String) +System.Enum.ToString(System.String,System.IFormatProvider) +System.Enum.TryFormat``1(``0,System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char}) +System.Enum.TryParse(System.Type,System.ReadOnlySpan{System.Char},System.Boolean,System.Object@) +System.Enum.TryParse(System.Type,System.ReadOnlySpan{System.Char},System.Object@) +System.Enum.TryParse(System.Type,System.String,System.Boolean,System.Object@) +System.Enum.TryParse(System.Type,System.String,System.Object@) +System.Enum.TryParse``1(System.ReadOnlySpan{System.Char},System.Boolean,``0@) +System.Enum.TryParse``1(System.ReadOnlySpan{System.Char},``0@) +System.Enum.TryParse``1(System.String,System.Boolean,``0@) +System.Enum.TryParse``1(System.String,``0@) +System.Environment +System.Environment.get_CurrentManagedThreadId +System.Environment.get_NewLine +System.EventArgs +System.EventArgs.#ctor +System.EventArgs.Empty +System.EventHandler +System.EventHandler.#ctor(System.Object,System.IntPtr) +System.EventHandler.BeginInvoke(System.Object,System.EventArgs,System.AsyncCallback,System.Object) +System.EventHandler.EndInvoke(System.IAsyncResult) +System.EventHandler.Invoke(System.Object,System.EventArgs) +System.EventHandler`1 +System.EventHandler`1.#ctor(System.Object,System.IntPtr) +System.EventHandler`1.BeginInvoke(System.Object,`0,System.AsyncCallback,System.Object) +System.EventHandler`1.EndInvoke(System.IAsyncResult) +System.EventHandler`1.Invoke(System.Object,`0) +System.Exception +System.Exception.#ctor +System.Exception.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Exception.#ctor(System.String) +System.Exception.#ctor(System.String,System.Exception) +System.Exception.GetBaseException +System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Exception.GetType +System.Exception.ToString +System.Exception.add_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs}) +System.Exception.get_Data +System.Exception.get_HResult +System.Exception.get_HelpLink +System.Exception.get_InnerException +System.Exception.get_Message +System.Exception.get_Source +System.Exception.get_StackTrace +System.Exception.get_TargetSite +System.Exception.remove_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs}) +System.Exception.set_HResult(System.Int32) +System.Exception.set_HelpLink(System.String) +System.Exception.set_Source(System.String) +System.ExecutionEngineException +System.ExecutionEngineException.#ctor +System.ExecutionEngineException.#ctor(System.String) +System.ExecutionEngineException.#ctor(System.String,System.Exception) +System.FieldAccessException +System.FieldAccessException.#ctor +System.FieldAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.FieldAccessException.#ctor(System.String) +System.FieldAccessException.#ctor(System.String,System.Exception) +System.FileStyleUriParser +System.FileStyleUriParser.#ctor +System.FlagsAttribute +System.FlagsAttribute.#ctor +System.FormatException +System.FormatException.#ctor +System.FormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.FormatException.#ctor(System.String) +System.FormatException.#ctor(System.String,System.Exception) +System.FormattableString +System.FormattableString.#ctor +System.FormattableString.CurrentCulture(System.FormattableString) +System.FormattableString.GetArgument(System.Int32) +System.FormattableString.GetArguments +System.FormattableString.Invariant(System.FormattableString) +System.FormattableString.ToString +System.FormattableString.ToString(System.IFormatProvider) +System.FormattableString.get_ArgumentCount +System.FormattableString.get_Format +System.FtpStyleUriParser +System.FtpStyleUriParser.#ctor +System.Func`1 +System.Func`1.#ctor(System.Object,System.IntPtr) +System.Func`1.BeginInvoke(System.AsyncCallback,System.Object) +System.Func`1.EndInvoke(System.IAsyncResult) +System.Func`1.Invoke +System.Func`10 +System.Func`10.#ctor(System.Object,System.IntPtr) +System.Func`10.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,System.AsyncCallback,System.Object) +System.Func`10.EndInvoke(System.IAsyncResult) +System.Func`10.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8) +System.Func`11 +System.Func`11.#ctor(System.Object,System.IntPtr) +System.Func`11.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,System.AsyncCallback,System.Object) +System.Func`11.EndInvoke(System.IAsyncResult) +System.Func`11.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9) +System.Func`12 +System.Func`12.#ctor(System.Object,System.IntPtr) +System.Func`12.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,System.AsyncCallback,System.Object) +System.Func`12.EndInvoke(System.IAsyncResult) +System.Func`12.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10) +System.Func`13 +System.Func`13.#ctor(System.Object,System.IntPtr) +System.Func`13.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,System.AsyncCallback,System.Object) +System.Func`13.EndInvoke(System.IAsyncResult) +System.Func`13.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11) +System.Func`14 +System.Func`14.#ctor(System.Object,System.IntPtr) +System.Func`14.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,System.AsyncCallback,System.Object) +System.Func`14.EndInvoke(System.IAsyncResult) +System.Func`14.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12) +System.Func`15 +System.Func`15.#ctor(System.Object,System.IntPtr) +System.Func`15.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,System.AsyncCallback,System.Object) +System.Func`15.EndInvoke(System.IAsyncResult) +System.Func`15.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13) +System.Func`16 +System.Func`16.#ctor(System.Object,System.IntPtr) +System.Func`16.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,System.AsyncCallback,System.Object) +System.Func`16.EndInvoke(System.IAsyncResult) +System.Func`16.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14) +System.Func`17 +System.Func`17.#ctor(System.Object,System.IntPtr) +System.Func`17.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15,System.AsyncCallback,System.Object) +System.Func`17.EndInvoke(System.IAsyncResult) +System.Func`17.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15) +System.Func`2 +System.Func`2.#ctor(System.Object,System.IntPtr) +System.Func`2.BeginInvoke(`0,System.AsyncCallback,System.Object) +System.Func`2.EndInvoke(System.IAsyncResult) +System.Func`2.Invoke(`0) +System.Func`3 +System.Func`3.#ctor(System.Object,System.IntPtr) +System.Func`3.BeginInvoke(`0,`1,System.AsyncCallback,System.Object) +System.Func`3.EndInvoke(System.IAsyncResult) +System.Func`3.Invoke(`0,`1) +System.Func`4 +System.Func`4.#ctor(System.Object,System.IntPtr) +System.Func`4.BeginInvoke(`0,`1,`2,System.AsyncCallback,System.Object) +System.Func`4.EndInvoke(System.IAsyncResult) +System.Func`4.Invoke(`0,`1,`2) +System.Func`5 +System.Func`5.#ctor(System.Object,System.IntPtr) +System.Func`5.BeginInvoke(`0,`1,`2,`3,System.AsyncCallback,System.Object) +System.Func`5.EndInvoke(System.IAsyncResult) +System.Func`5.Invoke(`0,`1,`2,`3) +System.Func`6 +System.Func`6.#ctor(System.Object,System.IntPtr) +System.Func`6.BeginInvoke(`0,`1,`2,`3,`4,System.AsyncCallback,System.Object) +System.Func`6.EndInvoke(System.IAsyncResult) +System.Func`6.Invoke(`0,`1,`2,`3,`4) +System.Func`7 +System.Func`7.#ctor(System.Object,System.IntPtr) +System.Func`7.BeginInvoke(`0,`1,`2,`3,`4,`5,System.AsyncCallback,System.Object) +System.Func`7.EndInvoke(System.IAsyncResult) +System.Func`7.Invoke(`0,`1,`2,`3,`4,`5) +System.Func`8 +System.Func`8.#ctor(System.Object,System.IntPtr) +System.Func`8.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,System.AsyncCallback,System.Object) +System.Func`8.EndInvoke(System.IAsyncResult) +System.Func`8.Invoke(`0,`1,`2,`3,`4,`5,`6) +System.Func`9 +System.Func`9.#ctor(System.Object,System.IntPtr) +System.Func`9.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,System.AsyncCallback,System.Object) +System.Func`9.EndInvoke(System.IAsyncResult) +System.Func`9.Invoke(`0,`1,`2,`3,`4,`5,`6,`7) +System.GenericUriParser +System.GenericUriParser.#ctor(System.GenericUriParserOptions) +System.GenericUriParserOptions +System.GenericUriParserOptions.AllowEmptyAuthority +System.GenericUriParserOptions.Default +System.GenericUriParserOptions.DontCompressPath +System.GenericUriParserOptions.DontConvertPathBackslashes +System.GenericUriParserOptions.DontUnescapePathDotsAndSlashes +System.GenericUriParserOptions.GenericAuthority +System.GenericUriParserOptions.Idn +System.GenericUriParserOptions.IriParsing +System.GenericUriParserOptions.NoFragment +System.GenericUriParserOptions.NoPort +System.GenericUriParserOptions.NoQuery +System.GenericUriParserOptions.NoUserInfo +System.Globalization.Calendar +System.Globalization.Calendar.#ctor +System.Globalization.Calendar.AddDays(System.DateTime,System.Int32) +System.Globalization.Calendar.AddHours(System.DateTime,System.Int32) +System.Globalization.Calendar.AddMilliseconds(System.DateTime,System.Double) +System.Globalization.Calendar.AddMinutes(System.DateTime,System.Int32) +System.Globalization.Calendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.Calendar.AddSeconds(System.DateTime,System.Int32) +System.Globalization.Calendar.AddWeeks(System.DateTime,System.Int32) +System.Globalization.Calendar.AddYears(System.DateTime,System.Int32) +System.Globalization.Calendar.Clone +System.Globalization.Calendar.CurrentEra +System.Globalization.Calendar.GetDayOfMonth(System.DateTime) +System.Globalization.Calendar.GetDayOfWeek(System.DateTime) +System.Globalization.Calendar.GetDayOfYear(System.DateTime) +System.Globalization.Calendar.GetDaysInMonth(System.Int32,System.Int32) +System.Globalization.Calendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.Calendar.GetDaysInYear(System.Int32) +System.Globalization.Calendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.Calendar.GetEra(System.DateTime) +System.Globalization.Calendar.GetHour(System.DateTime) +System.Globalization.Calendar.GetLeapMonth(System.Int32) +System.Globalization.Calendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.Calendar.GetMilliseconds(System.DateTime) +System.Globalization.Calendar.GetMinute(System.DateTime) +System.Globalization.Calendar.GetMonth(System.DateTime) +System.Globalization.Calendar.GetMonthsInYear(System.Int32) +System.Globalization.Calendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.Calendar.GetSecond(System.DateTime) +System.Globalization.Calendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +System.Globalization.Calendar.GetYear(System.DateTime) +System.Globalization.Calendar.IsLeapDay(System.Int32,System.Int32,System.Int32) +System.Globalization.Calendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.Calendar.IsLeapMonth(System.Int32,System.Int32) +System.Globalization.Calendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.Calendar.IsLeapYear(System.Int32) +System.Globalization.Calendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.Calendar.ReadOnly(System.Globalization.Calendar) +System.Globalization.Calendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.Calendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.Calendar.ToFourDigitYear(System.Int32) +System.Globalization.Calendar.get_AlgorithmType +System.Globalization.Calendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.Calendar.get_Eras +System.Globalization.Calendar.get_IsReadOnly +System.Globalization.Calendar.get_MaxSupportedDateTime +System.Globalization.Calendar.get_MinSupportedDateTime +System.Globalization.Calendar.get_TwoDigitYearMax +System.Globalization.Calendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.CalendarAlgorithmType +System.Globalization.CalendarAlgorithmType.LunarCalendar +System.Globalization.CalendarAlgorithmType.LunisolarCalendar +System.Globalization.CalendarAlgorithmType.SolarCalendar +System.Globalization.CalendarAlgorithmType.Unknown +System.Globalization.CalendarWeekRule +System.Globalization.CalendarWeekRule.FirstDay +System.Globalization.CalendarWeekRule.FirstFourDayWeek +System.Globalization.CalendarWeekRule.FirstFullWeek +System.Globalization.CharUnicodeInfo +System.Globalization.CharUnicodeInfo.GetDecimalDigitValue(System.Char) +System.Globalization.CharUnicodeInfo.GetDecimalDigitValue(System.String,System.Int32) +System.Globalization.CharUnicodeInfo.GetDigitValue(System.Char) +System.Globalization.CharUnicodeInfo.GetDigitValue(System.String,System.Int32) +System.Globalization.CharUnicodeInfo.GetNumericValue(System.Char) +System.Globalization.CharUnicodeInfo.GetNumericValue(System.String,System.Int32) +System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Char) +System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Int32) +System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.String,System.Int32) +System.Globalization.ChineseLunisolarCalendar +System.Globalization.ChineseLunisolarCalendar.#ctor +System.Globalization.ChineseLunisolarCalendar.ChineseEra +System.Globalization.ChineseLunisolarCalendar.GetEra(System.DateTime) +System.Globalization.ChineseLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.ChineseLunisolarCalendar.get_Eras +System.Globalization.ChineseLunisolarCalendar.get_MaxSupportedDateTime +System.Globalization.ChineseLunisolarCalendar.get_MinSupportedDateTime +System.Globalization.CompareInfo +System.Globalization.CompareInfo.Compare(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32) +System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.String,System.Int32) +System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.String,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.Compare(System.String,System.String) +System.Globalization.CompareInfo.Compare(System.String,System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.Equals(System.Object) +System.Globalization.CompareInfo.GetCompareInfo(System.Int32) +System.Globalization.CompareInfo.GetCompareInfo(System.Int32,System.Reflection.Assembly) +System.Globalization.CompareInfo.GetCompareInfo(System.String) +System.Globalization.CompareInfo.GetCompareInfo(System.String,System.Reflection.Assembly) +System.Globalization.CompareInfo.GetHashCode +System.Globalization.CompareInfo.GetHashCode(System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.GetHashCode(System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.GetSortKey(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.GetSortKey(System.String) +System.Globalization.CompareInfo.GetSortKey(System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.GetSortKeyLength(System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.Text.Rune,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.String,System.Char) +System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32) +System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Int32) +System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.String,System.String) +System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32) +System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Int32) +System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IsPrefix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IsPrefix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +System.Globalization.CompareInfo.IsPrefix(System.String,System.String) +System.Globalization.CompareInfo.IsPrefix(System.String,System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IsSortable(System.Char) +System.Globalization.CompareInfo.IsSortable(System.ReadOnlySpan{System.Char}) +System.Globalization.CompareInfo.IsSortable(System.String) +System.Globalization.CompareInfo.IsSortable(System.Text.Rune) +System.Globalization.CompareInfo.IsSuffix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.IsSuffix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +System.Globalization.CompareInfo.IsSuffix(System.String,System.String) +System.Globalization.CompareInfo.IsSuffix(System.String,System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.Text.Rune,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Int32) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.String) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Int32) +System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) +System.Globalization.CompareInfo.ToString +System.Globalization.CompareInfo.get_LCID +System.Globalization.CompareInfo.get_Name +System.Globalization.CompareInfo.get_Version +System.Globalization.CompareOptions +System.Globalization.CompareOptions.IgnoreCase +System.Globalization.CompareOptions.IgnoreKanaType +System.Globalization.CompareOptions.IgnoreNonSpace +System.Globalization.CompareOptions.IgnoreSymbols +System.Globalization.CompareOptions.IgnoreWidth +System.Globalization.CompareOptions.None +System.Globalization.CompareOptions.Ordinal +System.Globalization.CompareOptions.OrdinalIgnoreCase +System.Globalization.CompareOptions.StringSort +System.Globalization.CultureInfo +System.Globalization.CultureInfo.#ctor(System.Int32) +System.Globalization.CultureInfo.#ctor(System.Int32,System.Boolean) +System.Globalization.CultureInfo.#ctor(System.String) +System.Globalization.CultureInfo.#ctor(System.String,System.Boolean) +System.Globalization.CultureInfo.ClearCachedData +System.Globalization.CultureInfo.Clone +System.Globalization.CultureInfo.CreateSpecificCulture(System.String) +System.Globalization.CultureInfo.Equals(System.Object) +System.Globalization.CultureInfo.GetConsoleFallbackUICulture +System.Globalization.CultureInfo.GetCultureInfo(System.Int32) +System.Globalization.CultureInfo.GetCultureInfo(System.String) +System.Globalization.CultureInfo.GetCultureInfo(System.String,System.Boolean) +System.Globalization.CultureInfo.GetCultureInfo(System.String,System.String) +System.Globalization.CultureInfo.GetCultureInfoByIetfLanguageTag(System.String) +System.Globalization.CultureInfo.GetCultures(System.Globalization.CultureTypes) +System.Globalization.CultureInfo.GetFormat(System.Type) +System.Globalization.CultureInfo.GetHashCode +System.Globalization.CultureInfo.ReadOnly(System.Globalization.CultureInfo) +System.Globalization.CultureInfo.ToString +System.Globalization.CultureInfo.get_Calendar +System.Globalization.CultureInfo.get_CompareInfo +System.Globalization.CultureInfo.get_CultureTypes +System.Globalization.CultureInfo.get_CurrentCulture +System.Globalization.CultureInfo.get_CurrentUICulture +System.Globalization.CultureInfo.get_DateTimeFormat +System.Globalization.CultureInfo.get_DefaultThreadCurrentCulture +System.Globalization.CultureInfo.get_DefaultThreadCurrentUICulture +System.Globalization.CultureInfo.get_DisplayName +System.Globalization.CultureInfo.get_EnglishName +System.Globalization.CultureInfo.get_IetfLanguageTag +System.Globalization.CultureInfo.get_InstalledUICulture +System.Globalization.CultureInfo.get_InvariantCulture +System.Globalization.CultureInfo.get_IsNeutralCulture +System.Globalization.CultureInfo.get_IsReadOnly +System.Globalization.CultureInfo.get_KeyboardLayoutId +System.Globalization.CultureInfo.get_LCID +System.Globalization.CultureInfo.get_Name +System.Globalization.CultureInfo.get_NativeName +System.Globalization.CultureInfo.get_NumberFormat +System.Globalization.CultureInfo.get_OptionalCalendars +System.Globalization.CultureInfo.get_Parent +System.Globalization.CultureInfo.get_TextInfo +System.Globalization.CultureInfo.get_ThreeLetterISOLanguageName +System.Globalization.CultureInfo.get_ThreeLetterWindowsLanguageName +System.Globalization.CultureInfo.get_TwoLetterISOLanguageName +System.Globalization.CultureInfo.get_UseUserOverride +System.Globalization.CultureNotFoundException +System.Globalization.CultureNotFoundException.#ctor +System.Globalization.CultureNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Globalization.CultureNotFoundException.#ctor(System.String) +System.Globalization.CultureNotFoundException.#ctor(System.String,System.Exception) +System.Globalization.CultureNotFoundException.#ctor(System.String,System.Int32,System.Exception) +System.Globalization.CultureNotFoundException.#ctor(System.String,System.Int32,System.String) +System.Globalization.CultureNotFoundException.#ctor(System.String,System.String) +System.Globalization.CultureNotFoundException.#ctor(System.String,System.String,System.Exception) +System.Globalization.CultureNotFoundException.#ctor(System.String,System.String,System.String) +System.Globalization.CultureNotFoundException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Globalization.CultureNotFoundException.get_InvalidCultureId +System.Globalization.CultureNotFoundException.get_InvalidCultureName +System.Globalization.CultureNotFoundException.get_Message +System.Globalization.CultureTypes +System.Globalization.CultureTypes.AllCultures +System.Globalization.CultureTypes.FrameworkCultures +System.Globalization.CultureTypes.InstalledWin32Cultures +System.Globalization.CultureTypes.NeutralCultures +System.Globalization.CultureTypes.ReplacementCultures +System.Globalization.CultureTypes.SpecificCultures +System.Globalization.CultureTypes.UserCustomCulture +System.Globalization.CultureTypes.WindowsOnlyCultures +System.Globalization.DateTimeFormatInfo +System.Globalization.DateTimeFormatInfo.#ctor +System.Globalization.DateTimeFormatInfo.Clone +System.Globalization.DateTimeFormatInfo.GetAbbreviatedDayName(System.DayOfWeek) +System.Globalization.DateTimeFormatInfo.GetAbbreviatedEraName(System.Int32) +System.Globalization.DateTimeFormatInfo.GetAbbreviatedMonthName(System.Int32) +System.Globalization.DateTimeFormatInfo.GetAllDateTimePatterns +System.Globalization.DateTimeFormatInfo.GetAllDateTimePatterns(System.Char) +System.Globalization.DateTimeFormatInfo.GetDayName(System.DayOfWeek) +System.Globalization.DateTimeFormatInfo.GetEra(System.String) +System.Globalization.DateTimeFormatInfo.GetEraName(System.Int32) +System.Globalization.DateTimeFormatInfo.GetFormat(System.Type) +System.Globalization.DateTimeFormatInfo.GetInstance(System.IFormatProvider) +System.Globalization.DateTimeFormatInfo.GetMonthName(System.Int32) +System.Globalization.DateTimeFormatInfo.GetShortestDayName(System.DayOfWeek) +System.Globalization.DateTimeFormatInfo.ReadOnly(System.Globalization.DateTimeFormatInfo) +System.Globalization.DateTimeFormatInfo.SetAllDateTimePatterns(System.String[],System.Char) +System.Globalization.DateTimeFormatInfo.get_AMDesignator +System.Globalization.DateTimeFormatInfo.get_AbbreviatedDayNames +System.Globalization.DateTimeFormatInfo.get_AbbreviatedMonthGenitiveNames +System.Globalization.DateTimeFormatInfo.get_AbbreviatedMonthNames +System.Globalization.DateTimeFormatInfo.get_Calendar +System.Globalization.DateTimeFormatInfo.get_CalendarWeekRule +System.Globalization.DateTimeFormatInfo.get_CurrentInfo +System.Globalization.DateTimeFormatInfo.get_DateSeparator +System.Globalization.DateTimeFormatInfo.get_DayNames +System.Globalization.DateTimeFormatInfo.get_FirstDayOfWeek +System.Globalization.DateTimeFormatInfo.get_FullDateTimePattern +System.Globalization.DateTimeFormatInfo.get_InvariantInfo +System.Globalization.DateTimeFormatInfo.get_IsReadOnly +System.Globalization.DateTimeFormatInfo.get_LongDatePattern +System.Globalization.DateTimeFormatInfo.get_LongTimePattern +System.Globalization.DateTimeFormatInfo.get_MonthDayPattern +System.Globalization.DateTimeFormatInfo.get_MonthGenitiveNames +System.Globalization.DateTimeFormatInfo.get_MonthNames +System.Globalization.DateTimeFormatInfo.get_NativeCalendarName +System.Globalization.DateTimeFormatInfo.get_PMDesignator +System.Globalization.DateTimeFormatInfo.get_RFC1123Pattern +System.Globalization.DateTimeFormatInfo.get_ShortDatePattern +System.Globalization.DateTimeFormatInfo.get_ShortTimePattern +System.Globalization.DateTimeFormatInfo.get_ShortestDayNames +System.Globalization.DateTimeFormatInfo.get_SortableDateTimePattern +System.Globalization.DateTimeFormatInfo.get_TimeSeparator +System.Globalization.DateTimeFormatInfo.get_UniversalSortableDateTimePattern +System.Globalization.DateTimeFormatInfo.get_YearMonthPattern +System.Globalization.DateTimeFormatInfo.set_AMDesignator(System.String) +System.Globalization.DateTimeFormatInfo.set_AbbreviatedDayNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_AbbreviatedMonthGenitiveNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_AbbreviatedMonthNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_Calendar(System.Globalization.Calendar) +System.Globalization.DateTimeFormatInfo.set_CalendarWeekRule(System.Globalization.CalendarWeekRule) +System.Globalization.DateTimeFormatInfo.set_DateSeparator(System.String) +System.Globalization.DateTimeFormatInfo.set_DayNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_FirstDayOfWeek(System.DayOfWeek) +System.Globalization.DateTimeFormatInfo.set_FullDateTimePattern(System.String) +System.Globalization.DateTimeFormatInfo.set_LongDatePattern(System.String) +System.Globalization.DateTimeFormatInfo.set_LongTimePattern(System.String) +System.Globalization.DateTimeFormatInfo.set_MonthDayPattern(System.String) +System.Globalization.DateTimeFormatInfo.set_MonthGenitiveNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_MonthNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_PMDesignator(System.String) +System.Globalization.DateTimeFormatInfo.set_ShortDatePattern(System.String) +System.Globalization.DateTimeFormatInfo.set_ShortTimePattern(System.String) +System.Globalization.DateTimeFormatInfo.set_ShortestDayNames(System.String[]) +System.Globalization.DateTimeFormatInfo.set_TimeSeparator(System.String) +System.Globalization.DateTimeFormatInfo.set_YearMonthPattern(System.String) +System.Globalization.DateTimeStyles +System.Globalization.DateTimeStyles.AdjustToUniversal +System.Globalization.DateTimeStyles.AllowInnerWhite +System.Globalization.DateTimeStyles.AllowLeadingWhite +System.Globalization.DateTimeStyles.AllowTrailingWhite +System.Globalization.DateTimeStyles.AllowWhiteSpaces +System.Globalization.DateTimeStyles.AssumeLocal +System.Globalization.DateTimeStyles.AssumeUniversal +System.Globalization.DateTimeStyles.NoCurrentDateDefault +System.Globalization.DateTimeStyles.None +System.Globalization.DateTimeStyles.RoundtripKind +System.Globalization.DaylightTime +System.Globalization.DaylightTime.#ctor(System.DateTime,System.DateTime,System.TimeSpan) +System.Globalization.DaylightTime.get_Delta +System.Globalization.DaylightTime.get_End +System.Globalization.DaylightTime.get_Start +System.Globalization.DigitShapes +System.Globalization.DigitShapes.Context +System.Globalization.DigitShapes.NativeNational +System.Globalization.DigitShapes.None +System.Globalization.EastAsianLunisolarCalendar +System.Globalization.EastAsianLunisolarCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetCelestialStem(System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.EastAsianLunisolarCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.EastAsianLunisolarCalendar.GetDayOfYear(System.DateTime) +System.Globalization.EastAsianLunisolarCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetMonth(System.DateTime) +System.Globalization.EastAsianLunisolarCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetSexagenaryYear(System.DateTime) +System.Globalization.EastAsianLunisolarCalendar.GetTerrestrialBranch(System.Int32) +System.Globalization.EastAsianLunisolarCalendar.GetYear(System.DateTime) +System.Globalization.EastAsianLunisolarCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.EastAsianLunisolarCalendar.ToFourDigitYear(System.Int32) +System.Globalization.EastAsianLunisolarCalendar.get_AlgorithmType +System.Globalization.EastAsianLunisolarCalendar.get_TwoDigitYearMax +System.Globalization.EastAsianLunisolarCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.GlobalizationExtensions +System.Globalization.GlobalizationExtensions.GetStringComparer(System.Globalization.CompareInfo,System.Globalization.CompareOptions) +System.Globalization.GregorianCalendar +System.Globalization.GregorianCalendar.#ctor +System.Globalization.GregorianCalendar.#ctor(System.Globalization.GregorianCalendarTypes) +System.Globalization.GregorianCalendar.ADEra +System.Globalization.GregorianCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.GregorianCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.GregorianCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.GregorianCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.GregorianCalendar.GetDayOfYear(System.DateTime) +System.Globalization.GregorianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.GregorianCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.GregorianCalendar.GetEra(System.DateTime) +System.Globalization.GregorianCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.GregorianCalendar.GetMonth(System.DateTime) +System.Globalization.GregorianCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.GregorianCalendar.GetYear(System.DateTime) +System.Globalization.GregorianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.GregorianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.GregorianCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.GregorianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.GregorianCalendar.ToFourDigitYear(System.Int32) +System.Globalization.GregorianCalendar.get_AlgorithmType +System.Globalization.GregorianCalendar.get_CalendarType +System.Globalization.GregorianCalendar.get_Eras +System.Globalization.GregorianCalendar.get_MaxSupportedDateTime +System.Globalization.GregorianCalendar.get_MinSupportedDateTime +System.Globalization.GregorianCalendar.get_TwoDigitYearMax +System.Globalization.GregorianCalendar.set_CalendarType(System.Globalization.GregorianCalendarTypes) +System.Globalization.GregorianCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.GregorianCalendarTypes +System.Globalization.GregorianCalendarTypes.Arabic +System.Globalization.GregorianCalendarTypes.Localized +System.Globalization.GregorianCalendarTypes.MiddleEastFrench +System.Globalization.GregorianCalendarTypes.TransliteratedEnglish +System.Globalization.GregorianCalendarTypes.TransliteratedFrench +System.Globalization.GregorianCalendarTypes.USEnglish +System.Globalization.HebrewCalendar +System.Globalization.HebrewCalendar.#ctor +System.Globalization.HebrewCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.HebrewCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.HebrewCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.HebrewCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.HebrewCalendar.GetDayOfYear(System.DateTime) +System.Globalization.HebrewCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.HebrewCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.HebrewCalendar.GetEra(System.DateTime) +System.Globalization.HebrewCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.HebrewCalendar.GetMonth(System.DateTime) +System.Globalization.HebrewCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.HebrewCalendar.GetYear(System.DateTime) +System.Globalization.HebrewCalendar.HebrewEra +System.Globalization.HebrewCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.HebrewCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.HebrewCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.HebrewCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.HebrewCalendar.ToFourDigitYear(System.Int32) +System.Globalization.HebrewCalendar.get_AlgorithmType +System.Globalization.HebrewCalendar.get_Eras +System.Globalization.HebrewCalendar.get_MaxSupportedDateTime +System.Globalization.HebrewCalendar.get_MinSupportedDateTime +System.Globalization.HebrewCalendar.get_TwoDigitYearMax +System.Globalization.HebrewCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.HijriCalendar +System.Globalization.HijriCalendar.#ctor +System.Globalization.HijriCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.HijriCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.HijriCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.HijriCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.HijriCalendar.GetDayOfYear(System.DateTime) +System.Globalization.HijriCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.HijriCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.HijriCalendar.GetEra(System.DateTime) +System.Globalization.HijriCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.HijriCalendar.GetMonth(System.DateTime) +System.Globalization.HijriCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.HijriCalendar.GetYear(System.DateTime) +System.Globalization.HijriCalendar.HijriEra +System.Globalization.HijriCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.HijriCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.HijriCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.HijriCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.HijriCalendar.ToFourDigitYear(System.Int32) +System.Globalization.HijriCalendar.get_AlgorithmType +System.Globalization.HijriCalendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.HijriCalendar.get_Eras +System.Globalization.HijriCalendar.get_HijriAdjustment +System.Globalization.HijriCalendar.get_MaxSupportedDateTime +System.Globalization.HijriCalendar.get_MinSupportedDateTime +System.Globalization.HijriCalendar.get_TwoDigitYearMax +System.Globalization.HijriCalendar.set_HijriAdjustment(System.Int32) +System.Globalization.HijriCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.ISOWeek +System.Globalization.ISOWeek.GetWeekOfYear(System.DateTime) +System.Globalization.ISOWeek.GetWeeksInYear(System.Int32) +System.Globalization.ISOWeek.GetYear(System.DateTime) +System.Globalization.ISOWeek.GetYearEnd(System.Int32) +System.Globalization.ISOWeek.GetYearStart(System.Int32) +System.Globalization.ISOWeek.ToDateTime(System.Int32,System.Int32,System.DayOfWeek) +System.Globalization.IdnMapping +System.Globalization.IdnMapping.#ctor +System.Globalization.IdnMapping.Equals(System.Object) +System.Globalization.IdnMapping.GetAscii(System.String) +System.Globalization.IdnMapping.GetAscii(System.String,System.Int32) +System.Globalization.IdnMapping.GetAscii(System.String,System.Int32,System.Int32) +System.Globalization.IdnMapping.GetHashCode +System.Globalization.IdnMapping.GetUnicode(System.String) +System.Globalization.IdnMapping.GetUnicode(System.String,System.Int32) +System.Globalization.IdnMapping.GetUnicode(System.String,System.Int32,System.Int32) +System.Globalization.IdnMapping.get_AllowUnassigned +System.Globalization.IdnMapping.get_UseStd3AsciiRules +System.Globalization.IdnMapping.set_AllowUnassigned(System.Boolean) +System.Globalization.IdnMapping.set_UseStd3AsciiRules(System.Boolean) +System.Globalization.JapaneseCalendar +System.Globalization.JapaneseCalendar.#ctor +System.Globalization.JapaneseCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.JapaneseCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.JapaneseCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.JapaneseCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.JapaneseCalendar.GetDayOfYear(System.DateTime) +System.Globalization.JapaneseCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.GetEra(System.DateTime) +System.Globalization.JapaneseCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.GetMonth(System.DateTime) +System.Globalization.JapaneseCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +System.Globalization.JapaneseCalendar.GetYear(System.DateTime) +System.Globalization.JapaneseCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.JapaneseCalendar.ToFourDigitYear(System.Int32) +System.Globalization.JapaneseCalendar.get_AlgorithmType +System.Globalization.JapaneseCalendar.get_Eras +System.Globalization.JapaneseCalendar.get_MaxSupportedDateTime +System.Globalization.JapaneseCalendar.get_MinSupportedDateTime +System.Globalization.JapaneseCalendar.get_TwoDigitYearMax +System.Globalization.JapaneseCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.JapaneseLunisolarCalendar +System.Globalization.JapaneseLunisolarCalendar.#ctor +System.Globalization.JapaneseLunisolarCalendar.GetEra(System.DateTime) +System.Globalization.JapaneseLunisolarCalendar.JapaneseEra +System.Globalization.JapaneseLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.JapaneseLunisolarCalendar.get_Eras +System.Globalization.JapaneseLunisolarCalendar.get_MaxSupportedDateTime +System.Globalization.JapaneseLunisolarCalendar.get_MinSupportedDateTime +System.Globalization.JulianCalendar +System.Globalization.JulianCalendar.#ctor +System.Globalization.JulianCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.JulianCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.JulianCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.JulianCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.JulianCalendar.GetDayOfYear(System.DateTime) +System.Globalization.JulianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.JulianCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.JulianCalendar.GetEra(System.DateTime) +System.Globalization.JulianCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.JulianCalendar.GetMonth(System.DateTime) +System.Globalization.JulianCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.JulianCalendar.GetYear(System.DateTime) +System.Globalization.JulianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.JulianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.JulianCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.JulianCalendar.JulianEra +System.Globalization.JulianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.JulianCalendar.ToFourDigitYear(System.Int32) +System.Globalization.JulianCalendar.get_AlgorithmType +System.Globalization.JulianCalendar.get_Eras +System.Globalization.JulianCalendar.get_MaxSupportedDateTime +System.Globalization.JulianCalendar.get_MinSupportedDateTime +System.Globalization.JulianCalendar.get_TwoDigitYearMax +System.Globalization.JulianCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.KoreanCalendar +System.Globalization.KoreanCalendar.#ctor +System.Globalization.KoreanCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.KoreanCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.KoreanCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.KoreanCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.KoreanCalendar.GetDayOfYear(System.DateTime) +System.Globalization.KoreanCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.KoreanCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.KoreanCalendar.GetEra(System.DateTime) +System.Globalization.KoreanCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.KoreanCalendar.GetMonth(System.DateTime) +System.Globalization.KoreanCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.KoreanCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +System.Globalization.KoreanCalendar.GetYear(System.DateTime) +System.Globalization.KoreanCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.KoreanCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.KoreanCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.KoreanCalendar.KoreanEra +System.Globalization.KoreanCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.KoreanCalendar.ToFourDigitYear(System.Int32) +System.Globalization.KoreanCalendar.get_AlgorithmType +System.Globalization.KoreanCalendar.get_Eras +System.Globalization.KoreanCalendar.get_MaxSupportedDateTime +System.Globalization.KoreanCalendar.get_MinSupportedDateTime +System.Globalization.KoreanCalendar.get_TwoDigitYearMax +System.Globalization.KoreanCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.KoreanLunisolarCalendar +System.Globalization.KoreanLunisolarCalendar.#ctor +System.Globalization.KoreanLunisolarCalendar.GetEra(System.DateTime) +System.Globalization.KoreanLunisolarCalendar.GregorianEra +System.Globalization.KoreanLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.KoreanLunisolarCalendar.get_Eras +System.Globalization.KoreanLunisolarCalendar.get_MaxSupportedDateTime +System.Globalization.KoreanLunisolarCalendar.get_MinSupportedDateTime +System.Globalization.NumberFormatInfo +System.Globalization.NumberFormatInfo.#ctor +System.Globalization.NumberFormatInfo.Clone +System.Globalization.NumberFormatInfo.GetFormat(System.Type) +System.Globalization.NumberFormatInfo.GetInstance(System.IFormatProvider) +System.Globalization.NumberFormatInfo.ReadOnly(System.Globalization.NumberFormatInfo) +System.Globalization.NumberFormatInfo.get_CurrencyDecimalDigits +System.Globalization.NumberFormatInfo.get_CurrencyDecimalSeparator +System.Globalization.NumberFormatInfo.get_CurrencyGroupSeparator +System.Globalization.NumberFormatInfo.get_CurrencyGroupSizes +System.Globalization.NumberFormatInfo.get_CurrencyNegativePattern +System.Globalization.NumberFormatInfo.get_CurrencyPositivePattern +System.Globalization.NumberFormatInfo.get_CurrencySymbol +System.Globalization.NumberFormatInfo.get_CurrentInfo +System.Globalization.NumberFormatInfo.get_DigitSubstitution +System.Globalization.NumberFormatInfo.get_InvariantInfo +System.Globalization.NumberFormatInfo.get_IsReadOnly +System.Globalization.NumberFormatInfo.get_NaNSymbol +System.Globalization.NumberFormatInfo.get_NativeDigits +System.Globalization.NumberFormatInfo.get_NegativeInfinitySymbol +System.Globalization.NumberFormatInfo.get_NegativeSign +System.Globalization.NumberFormatInfo.get_NumberDecimalDigits +System.Globalization.NumberFormatInfo.get_NumberDecimalSeparator +System.Globalization.NumberFormatInfo.get_NumberGroupSeparator +System.Globalization.NumberFormatInfo.get_NumberGroupSizes +System.Globalization.NumberFormatInfo.get_NumberNegativePattern +System.Globalization.NumberFormatInfo.get_PerMilleSymbol +System.Globalization.NumberFormatInfo.get_PercentDecimalDigits +System.Globalization.NumberFormatInfo.get_PercentDecimalSeparator +System.Globalization.NumberFormatInfo.get_PercentGroupSeparator +System.Globalization.NumberFormatInfo.get_PercentGroupSizes +System.Globalization.NumberFormatInfo.get_PercentNegativePattern +System.Globalization.NumberFormatInfo.get_PercentPositivePattern +System.Globalization.NumberFormatInfo.get_PercentSymbol +System.Globalization.NumberFormatInfo.get_PositiveInfinitySymbol +System.Globalization.NumberFormatInfo.get_PositiveSign +System.Globalization.NumberFormatInfo.set_CurrencyDecimalDigits(System.Int32) +System.Globalization.NumberFormatInfo.set_CurrencyDecimalSeparator(System.String) +System.Globalization.NumberFormatInfo.set_CurrencyGroupSeparator(System.String) +System.Globalization.NumberFormatInfo.set_CurrencyGroupSizes(System.Int32[]) +System.Globalization.NumberFormatInfo.set_CurrencyNegativePattern(System.Int32) +System.Globalization.NumberFormatInfo.set_CurrencyPositivePattern(System.Int32) +System.Globalization.NumberFormatInfo.set_CurrencySymbol(System.String) +System.Globalization.NumberFormatInfo.set_DigitSubstitution(System.Globalization.DigitShapes) +System.Globalization.NumberFormatInfo.set_NaNSymbol(System.String) +System.Globalization.NumberFormatInfo.set_NativeDigits(System.String[]) +System.Globalization.NumberFormatInfo.set_NegativeInfinitySymbol(System.String) +System.Globalization.NumberFormatInfo.set_NegativeSign(System.String) +System.Globalization.NumberFormatInfo.set_NumberDecimalDigits(System.Int32) +System.Globalization.NumberFormatInfo.set_NumberDecimalSeparator(System.String) +System.Globalization.NumberFormatInfo.set_NumberGroupSeparator(System.String) +System.Globalization.NumberFormatInfo.set_NumberGroupSizes(System.Int32[]) +System.Globalization.NumberFormatInfo.set_NumberNegativePattern(System.Int32) +System.Globalization.NumberFormatInfo.set_PerMilleSymbol(System.String) +System.Globalization.NumberFormatInfo.set_PercentDecimalDigits(System.Int32) +System.Globalization.NumberFormatInfo.set_PercentDecimalSeparator(System.String) +System.Globalization.NumberFormatInfo.set_PercentGroupSeparator(System.String) +System.Globalization.NumberFormatInfo.set_PercentGroupSizes(System.Int32[]) +System.Globalization.NumberFormatInfo.set_PercentNegativePattern(System.Int32) +System.Globalization.NumberFormatInfo.set_PercentPositivePattern(System.Int32) +System.Globalization.NumberFormatInfo.set_PercentSymbol(System.String) +System.Globalization.NumberFormatInfo.set_PositiveInfinitySymbol(System.String) +System.Globalization.NumberFormatInfo.set_PositiveSign(System.String) +System.Globalization.NumberStyles +System.Globalization.NumberStyles.AllowBinarySpecifier +System.Globalization.NumberStyles.AllowCurrencySymbol +System.Globalization.NumberStyles.AllowDecimalPoint +System.Globalization.NumberStyles.AllowExponent +System.Globalization.NumberStyles.AllowHexSpecifier +System.Globalization.NumberStyles.AllowLeadingSign +System.Globalization.NumberStyles.AllowLeadingWhite +System.Globalization.NumberStyles.AllowParentheses +System.Globalization.NumberStyles.AllowThousands +System.Globalization.NumberStyles.AllowTrailingSign +System.Globalization.NumberStyles.AllowTrailingWhite +System.Globalization.NumberStyles.Any +System.Globalization.NumberStyles.BinaryNumber +System.Globalization.NumberStyles.Currency +System.Globalization.NumberStyles.Float +System.Globalization.NumberStyles.HexNumber +System.Globalization.NumberStyles.Integer +System.Globalization.NumberStyles.None +System.Globalization.NumberStyles.Number +System.Globalization.PersianCalendar +System.Globalization.PersianCalendar.#ctor +System.Globalization.PersianCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.PersianCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.PersianCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.PersianCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.PersianCalendar.GetDayOfYear(System.DateTime) +System.Globalization.PersianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.PersianCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.PersianCalendar.GetEra(System.DateTime) +System.Globalization.PersianCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.PersianCalendar.GetMonth(System.DateTime) +System.Globalization.PersianCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.PersianCalendar.GetYear(System.DateTime) +System.Globalization.PersianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.PersianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.PersianCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.PersianCalendar.PersianEra +System.Globalization.PersianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.PersianCalendar.ToFourDigitYear(System.Int32) +System.Globalization.PersianCalendar.get_AlgorithmType +System.Globalization.PersianCalendar.get_Eras +System.Globalization.PersianCalendar.get_MaxSupportedDateTime +System.Globalization.PersianCalendar.get_MinSupportedDateTime +System.Globalization.PersianCalendar.get_TwoDigitYearMax +System.Globalization.PersianCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.RegionInfo +System.Globalization.RegionInfo.#ctor(System.Int32) +System.Globalization.RegionInfo.#ctor(System.String) +System.Globalization.RegionInfo.Equals(System.Object) +System.Globalization.RegionInfo.GetHashCode +System.Globalization.RegionInfo.ToString +System.Globalization.RegionInfo.get_CurrencyEnglishName +System.Globalization.RegionInfo.get_CurrencyNativeName +System.Globalization.RegionInfo.get_CurrencySymbol +System.Globalization.RegionInfo.get_CurrentRegion +System.Globalization.RegionInfo.get_DisplayName +System.Globalization.RegionInfo.get_EnglishName +System.Globalization.RegionInfo.get_GeoId +System.Globalization.RegionInfo.get_ISOCurrencySymbol +System.Globalization.RegionInfo.get_IsMetric +System.Globalization.RegionInfo.get_Name +System.Globalization.RegionInfo.get_NativeName +System.Globalization.RegionInfo.get_ThreeLetterISORegionName +System.Globalization.RegionInfo.get_ThreeLetterWindowsRegionName +System.Globalization.RegionInfo.get_TwoLetterISORegionName +System.Globalization.SortKey +System.Globalization.SortKey.Compare(System.Globalization.SortKey,System.Globalization.SortKey) +System.Globalization.SortKey.Equals(System.Object) +System.Globalization.SortKey.GetHashCode +System.Globalization.SortKey.ToString +System.Globalization.SortKey.get_KeyData +System.Globalization.SortKey.get_OriginalString +System.Globalization.SortVersion +System.Globalization.SortVersion.#ctor(System.Int32,System.Guid) +System.Globalization.SortVersion.Equals(System.Globalization.SortVersion) +System.Globalization.SortVersion.Equals(System.Object) +System.Globalization.SortVersion.GetHashCode +System.Globalization.SortVersion.get_FullVersion +System.Globalization.SortVersion.get_SortId +System.Globalization.SortVersion.op_Equality(System.Globalization.SortVersion,System.Globalization.SortVersion) +System.Globalization.SortVersion.op_Inequality(System.Globalization.SortVersion,System.Globalization.SortVersion) +System.Globalization.StringInfo +System.Globalization.StringInfo.#ctor +System.Globalization.StringInfo.#ctor(System.String) +System.Globalization.StringInfo.Equals(System.Object) +System.Globalization.StringInfo.GetHashCode +System.Globalization.StringInfo.GetNextTextElement(System.String) +System.Globalization.StringInfo.GetNextTextElement(System.String,System.Int32) +System.Globalization.StringInfo.GetNextTextElementLength(System.ReadOnlySpan{System.Char}) +System.Globalization.StringInfo.GetNextTextElementLength(System.String) +System.Globalization.StringInfo.GetNextTextElementLength(System.String,System.Int32) +System.Globalization.StringInfo.GetTextElementEnumerator(System.String) +System.Globalization.StringInfo.GetTextElementEnumerator(System.String,System.Int32) +System.Globalization.StringInfo.ParseCombiningCharacters(System.String) +System.Globalization.StringInfo.SubstringByTextElements(System.Int32) +System.Globalization.StringInfo.SubstringByTextElements(System.Int32,System.Int32) +System.Globalization.StringInfo.get_LengthInTextElements +System.Globalization.StringInfo.get_String +System.Globalization.StringInfo.set_String(System.String) +System.Globalization.TaiwanCalendar +System.Globalization.TaiwanCalendar.#ctor +System.Globalization.TaiwanCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.TaiwanCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.TaiwanCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.TaiwanCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.TaiwanCalendar.GetDayOfYear(System.DateTime) +System.Globalization.TaiwanCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.GetEra(System.DateTime) +System.Globalization.TaiwanCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.GetMonth(System.DateTime) +System.Globalization.TaiwanCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +System.Globalization.TaiwanCalendar.GetYear(System.DateTime) +System.Globalization.TaiwanCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.TaiwanCalendar.ToFourDigitYear(System.Int32) +System.Globalization.TaiwanCalendar.get_AlgorithmType +System.Globalization.TaiwanCalendar.get_Eras +System.Globalization.TaiwanCalendar.get_MaxSupportedDateTime +System.Globalization.TaiwanCalendar.get_MinSupportedDateTime +System.Globalization.TaiwanCalendar.get_TwoDigitYearMax +System.Globalization.TaiwanCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.TaiwanLunisolarCalendar +System.Globalization.TaiwanLunisolarCalendar.#ctor +System.Globalization.TaiwanLunisolarCalendar.GetEra(System.DateTime) +System.Globalization.TaiwanLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.TaiwanLunisolarCalendar.get_Eras +System.Globalization.TaiwanLunisolarCalendar.get_MaxSupportedDateTime +System.Globalization.TaiwanLunisolarCalendar.get_MinSupportedDateTime +System.Globalization.TextElementEnumerator +System.Globalization.TextElementEnumerator.GetTextElement +System.Globalization.TextElementEnumerator.MoveNext +System.Globalization.TextElementEnumerator.Reset +System.Globalization.TextElementEnumerator.get_Current +System.Globalization.TextElementEnumerator.get_ElementIndex +System.Globalization.TextInfo +System.Globalization.TextInfo.Clone +System.Globalization.TextInfo.Equals(System.Object) +System.Globalization.TextInfo.GetHashCode +System.Globalization.TextInfo.ReadOnly(System.Globalization.TextInfo) +System.Globalization.TextInfo.ToLower(System.Char) +System.Globalization.TextInfo.ToLower(System.String) +System.Globalization.TextInfo.ToString +System.Globalization.TextInfo.ToTitleCase(System.String) +System.Globalization.TextInfo.ToUpper(System.Char) +System.Globalization.TextInfo.ToUpper(System.String) +System.Globalization.TextInfo.get_ANSICodePage +System.Globalization.TextInfo.get_CultureName +System.Globalization.TextInfo.get_EBCDICCodePage +System.Globalization.TextInfo.get_IsReadOnly +System.Globalization.TextInfo.get_IsRightToLeft +System.Globalization.TextInfo.get_LCID +System.Globalization.TextInfo.get_ListSeparator +System.Globalization.TextInfo.get_MacCodePage +System.Globalization.TextInfo.get_OEMCodePage +System.Globalization.TextInfo.set_ListSeparator(System.String) +System.Globalization.ThaiBuddhistCalendar +System.Globalization.ThaiBuddhistCalendar.#ctor +System.Globalization.ThaiBuddhistCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.ThaiBuddhistCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.ThaiBuddhistCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.ThaiBuddhistCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.ThaiBuddhistCalendar.GetDayOfYear(System.DateTime) +System.Globalization.ThaiBuddhistCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.GetEra(System.DateTime) +System.Globalization.ThaiBuddhistCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.GetMonth(System.DateTime) +System.Globalization.ThaiBuddhistCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +System.Globalization.ThaiBuddhistCalendar.GetYear(System.DateTime) +System.Globalization.ThaiBuddhistCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.ThaiBuddhistEra +System.Globalization.ThaiBuddhistCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.ThaiBuddhistCalendar.ToFourDigitYear(System.Int32) +System.Globalization.ThaiBuddhistCalendar.get_AlgorithmType +System.Globalization.ThaiBuddhistCalendar.get_Eras +System.Globalization.ThaiBuddhistCalendar.get_MaxSupportedDateTime +System.Globalization.ThaiBuddhistCalendar.get_MinSupportedDateTime +System.Globalization.ThaiBuddhistCalendar.get_TwoDigitYearMax +System.Globalization.ThaiBuddhistCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.TimeSpanStyles +System.Globalization.TimeSpanStyles.AssumeNegative +System.Globalization.TimeSpanStyles.None +System.Globalization.UmAlQuraCalendar +System.Globalization.UmAlQuraCalendar.#ctor +System.Globalization.UmAlQuraCalendar.AddMonths(System.DateTime,System.Int32) +System.Globalization.UmAlQuraCalendar.AddYears(System.DateTime,System.Int32) +System.Globalization.UmAlQuraCalendar.GetDayOfMonth(System.DateTime) +System.Globalization.UmAlQuraCalendar.GetDayOfWeek(System.DateTime) +System.Globalization.UmAlQuraCalendar.GetDayOfYear(System.DateTime) +System.Globalization.UmAlQuraCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.GetDaysInYear(System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.GetEra(System.DateTime) +System.Globalization.UmAlQuraCalendar.GetLeapMonth(System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.GetMonth(System.DateTime) +System.Globalization.UmAlQuraCalendar.GetMonthsInYear(System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.GetYear(System.DateTime) +System.Globalization.UmAlQuraCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.IsLeapYear(System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.Globalization.UmAlQuraCalendar.ToFourDigitYear(System.Int32) +System.Globalization.UmAlQuraCalendar.UmAlQuraEra +System.Globalization.UmAlQuraCalendar.get_AlgorithmType +System.Globalization.UmAlQuraCalendar.get_DaysInYearBeforeMinSupportedYear +System.Globalization.UmAlQuraCalendar.get_Eras +System.Globalization.UmAlQuraCalendar.get_MaxSupportedDateTime +System.Globalization.UmAlQuraCalendar.get_MinSupportedDateTime +System.Globalization.UmAlQuraCalendar.get_TwoDigitYearMax +System.Globalization.UmAlQuraCalendar.set_TwoDigitYearMax(System.Int32) +System.Globalization.UnicodeCategory +System.Globalization.UnicodeCategory.ClosePunctuation +System.Globalization.UnicodeCategory.ConnectorPunctuation +System.Globalization.UnicodeCategory.Control +System.Globalization.UnicodeCategory.CurrencySymbol +System.Globalization.UnicodeCategory.DashPunctuation +System.Globalization.UnicodeCategory.DecimalDigitNumber +System.Globalization.UnicodeCategory.EnclosingMark +System.Globalization.UnicodeCategory.FinalQuotePunctuation +System.Globalization.UnicodeCategory.Format +System.Globalization.UnicodeCategory.InitialQuotePunctuation +System.Globalization.UnicodeCategory.LetterNumber +System.Globalization.UnicodeCategory.LineSeparator +System.Globalization.UnicodeCategory.LowercaseLetter +System.Globalization.UnicodeCategory.MathSymbol +System.Globalization.UnicodeCategory.ModifierLetter +System.Globalization.UnicodeCategory.ModifierSymbol +System.Globalization.UnicodeCategory.NonSpacingMark +System.Globalization.UnicodeCategory.OpenPunctuation +System.Globalization.UnicodeCategory.OtherLetter +System.Globalization.UnicodeCategory.OtherNotAssigned +System.Globalization.UnicodeCategory.OtherNumber +System.Globalization.UnicodeCategory.OtherPunctuation +System.Globalization.UnicodeCategory.OtherSymbol +System.Globalization.UnicodeCategory.ParagraphSeparator +System.Globalization.UnicodeCategory.PrivateUse +System.Globalization.UnicodeCategory.SpaceSeparator +System.Globalization.UnicodeCategory.SpacingCombiningMark +System.Globalization.UnicodeCategory.Surrogate +System.Globalization.UnicodeCategory.TitlecaseLetter +System.Globalization.UnicodeCategory.UppercaseLetter +System.GopherStyleUriParser +System.GopherStyleUriParser.#ctor +System.Guid +System.Guid.#ctor(System.Byte[]) +System.Guid.#ctor(System.Int32,System.Int16,System.Int16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) +System.Guid.#ctor(System.Int32,System.Int16,System.Int16,System.Byte[]) +System.Guid.#ctor(System.ReadOnlySpan{System.Byte}) +System.Guid.#ctor(System.ReadOnlySpan{System.Byte},System.Boolean) +System.Guid.#ctor(System.String) +System.Guid.#ctor(System.UInt32,System.UInt16,System.UInt16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) +System.Guid.CompareTo(System.Guid) +System.Guid.CompareTo(System.Object) +System.Guid.CreateVersion7 +System.Guid.CreateVersion7(System.DateTimeOffset) +System.Guid.Empty +System.Guid.Equals(System.Guid) +System.Guid.Equals(System.Object) +System.Guid.GetHashCode +System.Guid.NewGuid +System.Guid.Parse(System.ReadOnlySpan{System.Char}) +System.Guid.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Guid.Parse(System.String) +System.Guid.Parse(System.String,System.IFormatProvider) +System.Guid.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.Guid.ParseExact(System.String,System.String) +System.Guid.ToByteArray +System.Guid.ToByteArray(System.Boolean) +System.Guid.ToString +System.Guid.ToString(System.String) +System.Guid.ToString(System.String,System.IFormatProvider) +System.Guid.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char}) +System.Guid.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char}) +System.Guid.TryParse(System.ReadOnlySpan{System.Char},System.Guid@) +System.Guid.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Guid@) +System.Guid.TryParse(System.String,System.Guid@) +System.Guid.TryParse(System.String,System.IFormatProvider,System.Guid@) +System.Guid.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Guid@) +System.Guid.TryParseExact(System.String,System.String,System.Guid@) +System.Guid.TryWriteBytes(System.Span{System.Byte}) +System.Guid.TryWriteBytes(System.Span{System.Byte},System.Boolean,System.Int32@) +System.Guid.get_AllBitsSet +System.Guid.get_Variant +System.Guid.get_Version +System.Guid.op_Equality(System.Guid,System.Guid) +System.Guid.op_GreaterThan(System.Guid,System.Guid) +System.Guid.op_GreaterThanOrEqual(System.Guid,System.Guid) +System.Guid.op_Inequality(System.Guid,System.Guid) +System.Guid.op_LessThan(System.Guid,System.Guid) +System.Guid.op_LessThanOrEqual(System.Guid,System.Guid) +System.Half +System.Half.Abs(System.Half) +System.Half.Acos(System.Half) +System.Half.AcosPi(System.Half) +System.Half.Acosh(System.Half) +System.Half.Asin(System.Half) +System.Half.AsinPi(System.Half) +System.Half.Asinh(System.Half) +System.Half.Atan(System.Half) +System.Half.Atan2(System.Half,System.Half) +System.Half.Atan2Pi(System.Half,System.Half) +System.Half.AtanPi(System.Half) +System.Half.Atanh(System.Half) +System.Half.BitDecrement(System.Half) +System.Half.BitIncrement(System.Half) +System.Half.Cbrt(System.Half) +System.Half.Ceiling(System.Half) +System.Half.Clamp(System.Half,System.Half,System.Half) +System.Half.CompareTo(System.Half) +System.Half.CompareTo(System.Object) +System.Half.ConvertToIntegerNative``1(System.Half) +System.Half.ConvertToInteger``1(System.Half) +System.Half.CopySign(System.Half,System.Half) +System.Half.Cos(System.Half) +System.Half.CosPi(System.Half) +System.Half.Cosh(System.Half) +System.Half.CreateChecked``1(``0) +System.Half.CreateSaturating``1(``0) +System.Half.CreateTruncating``1(``0) +System.Half.DegreesToRadians(System.Half) +System.Half.Equals(System.Half) +System.Half.Equals(System.Object) +System.Half.Exp(System.Half) +System.Half.Exp10(System.Half) +System.Half.Exp10M1(System.Half) +System.Half.Exp2(System.Half) +System.Half.Exp2M1(System.Half) +System.Half.ExpM1(System.Half) +System.Half.Floor(System.Half) +System.Half.FusedMultiplyAdd(System.Half,System.Half,System.Half) +System.Half.GetHashCode +System.Half.Hypot(System.Half,System.Half) +System.Half.ILogB(System.Half) +System.Half.Ieee754Remainder(System.Half,System.Half) +System.Half.IsEvenInteger(System.Half) +System.Half.IsFinite(System.Half) +System.Half.IsInfinity(System.Half) +System.Half.IsInteger(System.Half) +System.Half.IsNaN(System.Half) +System.Half.IsNegative(System.Half) +System.Half.IsNegativeInfinity(System.Half) +System.Half.IsNormal(System.Half) +System.Half.IsOddInteger(System.Half) +System.Half.IsPositive(System.Half) +System.Half.IsPositiveInfinity(System.Half) +System.Half.IsPow2(System.Half) +System.Half.IsRealNumber(System.Half) +System.Half.IsSubnormal(System.Half) +System.Half.Lerp(System.Half,System.Half,System.Half) +System.Half.Log(System.Half) +System.Half.Log(System.Half,System.Half) +System.Half.Log10(System.Half) +System.Half.Log10P1(System.Half) +System.Half.Log2(System.Half) +System.Half.Log2P1(System.Half) +System.Half.LogP1(System.Half) +System.Half.Max(System.Half,System.Half) +System.Half.MaxMagnitude(System.Half,System.Half) +System.Half.MaxMagnitudeNumber(System.Half,System.Half) +System.Half.MaxNumber(System.Half,System.Half) +System.Half.Min(System.Half,System.Half) +System.Half.MinMagnitude(System.Half,System.Half) +System.Half.MinMagnitudeNumber(System.Half,System.Half) +System.Half.MinNumber(System.Half,System.Half) +System.Half.MultiplyAddEstimate(System.Half,System.Half,System.Half) +System.Half.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Half.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Half.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Half.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Half.Parse(System.String) +System.Half.Parse(System.String,System.Globalization.NumberStyles) +System.Half.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Half.Parse(System.String,System.IFormatProvider) +System.Half.Pow(System.Half,System.Half) +System.Half.RadiansToDegrees(System.Half) +System.Half.ReciprocalEstimate(System.Half) +System.Half.ReciprocalSqrtEstimate(System.Half) +System.Half.RootN(System.Half,System.Int32) +System.Half.Round(System.Half) +System.Half.Round(System.Half,System.Int32) +System.Half.Round(System.Half,System.Int32,System.MidpointRounding) +System.Half.Round(System.Half,System.MidpointRounding) +System.Half.ScaleB(System.Half,System.Int32) +System.Half.Sign(System.Half) +System.Half.Sin(System.Half) +System.Half.SinCos(System.Half) +System.Half.SinCosPi(System.Half) +System.Half.SinPi(System.Half) +System.Half.Sinh(System.Half) +System.Half.Sqrt(System.Half) +System.Half.Tan(System.Half) +System.Half.TanPi(System.Half) +System.Half.Tanh(System.Half) +System.Half.ToString +System.Half.ToString(System.IFormatProvider) +System.Half.ToString(System.String) +System.Half.ToString(System.String,System.IFormatProvider) +System.Half.Truncate(System.Half) +System.Half.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Half.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) +System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.Half@) +System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Half@) +System.Half.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) +System.Half.TryParse(System.ReadOnlySpan{System.Char},System.Half@) +System.Half.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Half@) +System.Half.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) +System.Half.TryParse(System.String,System.Half@) +System.Half.TryParse(System.String,System.IFormatProvider,System.Half@) +System.Half.get_E +System.Half.get_Epsilon +System.Half.get_MaxValue +System.Half.get_MinValue +System.Half.get_MultiplicativeIdentity +System.Half.get_NaN +System.Half.get_NegativeInfinity +System.Half.get_NegativeOne +System.Half.get_NegativeZero +System.Half.get_One +System.Half.get_Pi +System.Half.get_PositiveInfinity +System.Half.get_Tau +System.Half.get_Zero +System.Half.op_Addition(System.Half,System.Half) +System.Half.op_CheckedExplicit(System.Half)~System.Byte +System.Half.op_CheckedExplicit(System.Half)~System.Char +System.Half.op_CheckedExplicit(System.Half)~System.Int128 +System.Half.op_CheckedExplicit(System.Half)~System.Int16 +System.Half.op_CheckedExplicit(System.Half)~System.Int32 +System.Half.op_CheckedExplicit(System.Half)~System.Int64 +System.Half.op_CheckedExplicit(System.Half)~System.IntPtr +System.Half.op_CheckedExplicit(System.Half)~System.SByte +System.Half.op_CheckedExplicit(System.Half)~System.UInt128 +System.Half.op_CheckedExplicit(System.Half)~System.UInt16 +System.Half.op_CheckedExplicit(System.Half)~System.UInt32 +System.Half.op_CheckedExplicit(System.Half)~System.UInt64 +System.Half.op_CheckedExplicit(System.Half)~System.UIntPtr +System.Half.op_Decrement(System.Half) +System.Half.op_Division(System.Half,System.Half) +System.Half.op_Equality(System.Half,System.Half) +System.Half.op_Explicit(System.Char)~System.Half +System.Half.op_Explicit(System.Decimal)~System.Half +System.Half.op_Explicit(System.Double)~System.Half +System.Half.op_Explicit(System.Half)~System.Byte +System.Half.op_Explicit(System.Half)~System.Char +System.Half.op_Explicit(System.Half)~System.Decimal +System.Half.op_Explicit(System.Half)~System.Double +System.Half.op_Explicit(System.Half)~System.Int128 +System.Half.op_Explicit(System.Half)~System.Int16 +System.Half.op_Explicit(System.Half)~System.Int32 +System.Half.op_Explicit(System.Half)~System.Int64 +System.Half.op_Explicit(System.Half)~System.IntPtr +System.Half.op_Explicit(System.Half)~System.SByte +System.Half.op_Explicit(System.Half)~System.Single +System.Half.op_Explicit(System.Half)~System.UInt128 +System.Half.op_Explicit(System.Half)~System.UInt16 +System.Half.op_Explicit(System.Half)~System.UInt32 +System.Half.op_Explicit(System.Half)~System.UInt64 +System.Half.op_Explicit(System.Half)~System.UIntPtr +System.Half.op_Explicit(System.Int16)~System.Half +System.Half.op_Explicit(System.Int32)~System.Half +System.Half.op_Explicit(System.Int64)~System.Half +System.Half.op_Explicit(System.IntPtr)~System.Half +System.Half.op_Explicit(System.Single)~System.Half +System.Half.op_Explicit(System.UInt16)~System.Half +System.Half.op_Explicit(System.UInt32)~System.Half +System.Half.op_Explicit(System.UInt64)~System.Half +System.Half.op_Explicit(System.UIntPtr)~System.Half +System.Half.op_GreaterThan(System.Half,System.Half) +System.Half.op_GreaterThanOrEqual(System.Half,System.Half) +System.Half.op_Implicit(System.Byte)~System.Half +System.Half.op_Implicit(System.SByte)~System.Half +System.Half.op_Increment(System.Half) +System.Half.op_Inequality(System.Half,System.Half) +System.Half.op_LessThan(System.Half,System.Half) +System.Half.op_LessThanOrEqual(System.Half,System.Half) +System.Half.op_Modulus(System.Half,System.Half) +System.Half.op_Multiply(System.Half,System.Half) +System.Half.op_Subtraction(System.Half,System.Half) +System.Half.op_UnaryNegation(System.Half) +System.Half.op_UnaryPlus(System.Half) +System.HashCode +System.HashCode.AddBytes(System.ReadOnlySpan{System.Byte}) +System.HashCode.Add``1(``0) +System.HashCode.Add``1(``0,System.Collections.Generic.IEqualityComparer{``0}) +System.HashCode.Combine``1(``0) +System.HashCode.Combine``2(``0,``1) +System.HashCode.Combine``3(``0,``1,``2) +System.HashCode.Combine``4(``0,``1,``2,``3) +System.HashCode.Combine``5(``0,``1,``2,``3,``4) +System.HashCode.Combine``6(``0,``1,``2,``3,``4,``5) +System.HashCode.Combine``7(``0,``1,``2,``3,``4,``5,``6) +System.HashCode.Combine``8(``0,``1,``2,``3,``4,``5,``6,``7) +System.HashCode.Equals(System.Object) +System.HashCode.GetHashCode +System.HashCode.ToHashCode +System.HttpStyleUriParser +System.HttpStyleUriParser.#ctor +System.IAsyncDisposable +System.IAsyncDisposable.DisposeAsync +System.IAsyncResult +System.IAsyncResult.get_AsyncState +System.IAsyncResult.get_AsyncWaitHandle +System.IAsyncResult.get_CompletedSynchronously +System.IAsyncResult.get_IsCompleted +System.ICloneable +System.ICloneable.Clone +System.IComparable +System.IComparable.CompareTo(System.Object) +System.IComparable`1 +System.IComparable`1.CompareTo(`0) +System.IConvertible +System.IConvertible.GetTypeCode +System.IConvertible.ToBoolean(System.IFormatProvider) +System.IConvertible.ToByte(System.IFormatProvider) +System.IConvertible.ToChar(System.IFormatProvider) +System.IConvertible.ToDateTime(System.IFormatProvider) +System.IConvertible.ToDecimal(System.IFormatProvider) +System.IConvertible.ToDouble(System.IFormatProvider) +System.IConvertible.ToInt16(System.IFormatProvider) +System.IConvertible.ToInt32(System.IFormatProvider) +System.IConvertible.ToInt64(System.IFormatProvider) +System.IConvertible.ToSByte(System.IFormatProvider) +System.IConvertible.ToSingle(System.IFormatProvider) +System.IConvertible.ToString(System.IFormatProvider) +System.IConvertible.ToType(System.Type,System.IFormatProvider) +System.IConvertible.ToUInt16(System.IFormatProvider) +System.IConvertible.ToUInt32(System.IFormatProvider) +System.IConvertible.ToUInt64(System.IFormatProvider) +System.ICustomFormatter +System.ICustomFormatter.Format(System.String,System.Object,System.IFormatProvider) +System.IDisposable +System.IDisposable.Dispose +System.IEquatable`1 +System.IEquatable`1.Equals(`0) +System.IFormatProvider +System.IFormatProvider.GetFormat(System.Type) +System.IFormattable +System.IFormattable.ToString(System.String,System.IFormatProvider) +System.IObservable`1 +System.IObservable`1.Subscribe(System.IObserver{`0}) +System.IObserver`1 +System.IObserver`1.OnCompleted +System.IObserver`1.OnError(System.Exception) +System.IObserver`1.OnNext(`0) +System.IParsable`1 +System.IParsable`1.Parse(System.String,System.IFormatProvider) +System.IParsable`1.TryParse(System.String,System.IFormatProvider,`0@) +System.IProgress`1 +System.IProgress`1.Report(`0) +System.ISpanFormattable +System.ISpanFormattable.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.ISpanParsable`1 +System.ISpanParsable`1.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.ISpanParsable`1.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,`0@) +System.IUtf8SpanFormattable +System.IUtf8SpanFormattable.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.IUtf8SpanParsable`1 +System.IUtf8SpanParsable`1.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.IUtf8SpanParsable`1.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,`0@) +System.Index +System.Index.#ctor(System.Int32,System.Boolean) +System.Index.Equals(System.Index) +System.Index.Equals(System.Object) +System.Index.FromEnd(System.Int32) +System.Index.FromStart(System.Int32) +System.Index.GetHashCode +System.Index.GetOffset(System.Int32) +System.Index.ToString +System.Index.get_End +System.Index.get_IsFromEnd +System.Index.get_Start +System.Index.get_Value +System.Index.op_Implicit(System.Int32)~System.Index +System.IndexOutOfRangeException +System.IndexOutOfRangeException.#ctor +System.IndexOutOfRangeException.#ctor(System.String) +System.IndexOutOfRangeException.#ctor(System.String,System.Exception) +System.InsufficientExecutionStackException +System.InsufficientExecutionStackException.#ctor +System.InsufficientExecutionStackException.#ctor(System.String) +System.InsufficientExecutionStackException.#ctor(System.String,System.Exception) +System.InsufficientMemoryException +System.InsufficientMemoryException.#ctor +System.InsufficientMemoryException.#ctor(System.String) +System.InsufficientMemoryException.#ctor(System.String,System.Exception) +System.Int128 +System.Int128.#ctor(System.UInt64,System.UInt64) +System.Int128.Abs(System.Int128) +System.Int128.Clamp(System.Int128,System.Int128,System.Int128) +System.Int128.CompareTo(System.Int128) +System.Int128.CompareTo(System.Object) +System.Int128.CopySign(System.Int128,System.Int128) +System.Int128.CreateChecked``1(``0) +System.Int128.CreateSaturating``1(``0) +System.Int128.CreateTruncating``1(``0) +System.Int128.DivRem(System.Int128,System.Int128) +System.Int128.Equals(System.Int128) +System.Int128.Equals(System.Object) +System.Int128.GetHashCode +System.Int128.IsEvenInteger(System.Int128) +System.Int128.IsNegative(System.Int128) +System.Int128.IsOddInteger(System.Int128) +System.Int128.IsPositive(System.Int128) +System.Int128.IsPow2(System.Int128) +System.Int128.LeadingZeroCount(System.Int128) +System.Int128.Log2(System.Int128) +System.Int128.Max(System.Int128,System.Int128) +System.Int128.MaxMagnitude(System.Int128,System.Int128) +System.Int128.Min(System.Int128,System.Int128) +System.Int128.MinMagnitude(System.Int128,System.Int128) +System.Int128.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int128.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Int128.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int128.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int128.Parse(System.String) +System.Int128.Parse(System.String,System.Globalization.NumberStyles) +System.Int128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Int128.Parse(System.String,System.IFormatProvider) +System.Int128.PopCount(System.Int128) +System.Int128.RotateLeft(System.Int128,System.Int32) +System.Int128.RotateRight(System.Int128,System.Int32) +System.Int128.Sign(System.Int128) +System.Int128.ToString +System.Int128.ToString(System.IFormatProvider) +System.Int128.ToString(System.String) +System.Int128.ToString(System.String,System.IFormatProvider) +System.Int128.TrailingZeroCount(System.Int128) +System.Int128.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int128.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) +System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int128@) +System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.Int128@) +System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) +System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int128@) +System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.Int128@) +System.Int128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) +System.Int128.TryParse(System.String,System.IFormatProvider,System.Int128@) +System.Int128.TryParse(System.String,System.Int128@) +System.Int128.get_MaxValue +System.Int128.get_MinValue +System.Int128.get_NegativeOne +System.Int128.get_One +System.Int128.get_Zero +System.Int128.op_Addition(System.Int128,System.Int128) +System.Int128.op_BitwiseAnd(System.Int128,System.Int128) +System.Int128.op_BitwiseOr(System.Int128,System.Int128) +System.Int128.op_CheckedAddition(System.Int128,System.Int128) +System.Int128.op_CheckedDecrement(System.Int128) +System.Int128.op_CheckedDivision(System.Int128,System.Int128) +System.Int128.op_CheckedExplicit(System.Double)~System.Int128 +System.Int128.op_CheckedExplicit(System.Int128)~System.Byte +System.Int128.op_CheckedExplicit(System.Int128)~System.Char +System.Int128.op_CheckedExplicit(System.Int128)~System.Int16 +System.Int128.op_CheckedExplicit(System.Int128)~System.Int32 +System.Int128.op_CheckedExplicit(System.Int128)~System.Int64 +System.Int128.op_CheckedExplicit(System.Int128)~System.IntPtr +System.Int128.op_CheckedExplicit(System.Int128)~System.SByte +System.Int128.op_CheckedExplicit(System.Int128)~System.UInt128 +System.Int128.op_CheckedExplicit(System.Int128)~System.UInt16 +System.Int128.op_CheckedExplicit(System.Int128)~System.UInt32 +System.Int128.op_CheckedExplicit(System.Int128)~System.UInt64 +System.Int128.op_CheckedExplicit(System.Int128)~System.UIntPtr +System.Int128.op_CheckedExplicit(System.Single)~System.Int128 +System.Int128.op_CheckedIncrement(System.Int128) +System.Int128.op_CheckedMultiply(System.Int128,System.Int128) +System.Int128.op_CheckedSubtraction(System.Int128,System.Int128) +System.Int128.op_CheckedUnaryNegation(System.Int128) +System.Int128.op_Decrement(System.Int128) +System.Int128.op_Division(System.Int128,System.Int128) +System.Int128.op_Equality(System.Int128,System.Int128) +System.Int128.op_ExclusiveOr(System.Int128,System.Int128) +System.Int128.op_Explicit(System.Decimal)~System.Int128 +System.Int128.op_Explicit(System.Double)~System.Int128 +System.Int128.op_Explicit(System.Int128)~System.Byte +System.Int128.op_Explicit(System.Int128)~System.Char +System.Int128.op_Explicit(System.Int128)~System.Decimal +System.Int128.op_Explicit(System.Int128)~System.Double +System.Int128.op_Explicit(System.Int128)~System.Half +System.Int128.op_Explicit(System.Int128)~System.Int16 +System.Int128.op_Explicit(System.Int128)~System.Int32 +System.Int128.op_Explicit(System.Int128)~System.Int64 +System.Int128.op_Explicit(System.Int128)~System.IntPtr +System.Int128.op_Explicit(System.Int128)~System.SByte +System.Int128.op_Explicit(System.Int128)~System.Single +System.Int128.op_Explicit(System.Int128)~System.UInt128 +System.Int128.op_Explicit(System.Int128)~System.UInt16 +System.Int128.op_Explicit(System.Int128)~System.UInt32 +System.Int128.op_Explicit(System.Int128)~System.UInt64 +System.Int128.op_Explicit(System.Int128)~System.UIntPtr +System.Int128.op_Explicit(System.Single)~System.Int128 +System.Int128.op_GreaterThan(System.Int128,System.Int128) +System.Int128.op_GreaterThanOrEqual(System.Int128,System.Int128) +System.Int128.op_Implicit(System.Byte)~System.Int128 +System.Int128.op_Implicit(System.Char)~System.Int128 +System.Int128.op_Implicit(System.Int16)~System.Int128 +System.Int128.op_Implicit(System.Int32)~System.Int128 +System.Int128.op_Implicit(System.Int64)~System.Int128 +System.Int128.op_Implicit(System.IntPtr)~System.Int128 +System.Int128.op_Implicit(System.SByte)~System.Int128 +System.Int128.op_Implicit(System.UInt16)~System.Int128 +System.Int128.op_Implicit(System.UInt32)~System.Int128 +System.Int128.op_Implicit(System.UInt64)~System.Int128 +System.Int128.op_Implicit(System.UIntPtr)~System.Int128 +System.Int128.op_Increment(System.Int128) +System.Int128.op_Inequality(System.Int128,System.Int128) +System.Int128.op_LeftShift(System.Int128,System.Int32) +System.Int128.op_LessThan(System.Int128,System.Int128) +System.Int128.op_LessThanOrEqual(System.Int128,System.Int128) +System.Int128.op_Modulus(System.Int128,System.Int128) +System.Int128.op_Multiply(System.Int128,System.Int128) +System.Int128.op_OnesComplement(System.Int128) +System.Int128.op_RightShift(System.Int128,System.Int32) +System.Int128.op_Subtraction(System.Int128,System.Int128) +System.Int128.op_UnaryNegation(System.Int128) +System.Int128.op_UnaryPlus(System.Int128) +System.Int128.op_UnsignedRightShift(System.Int128,System.Int32) +System.Int16 +System.Int16.Abs(System.Int16) +System.Int16.Clamp(System.Int16,System.Int16,System.Int16) +System.Int16.CompareTo(System.Int16) +System.Int16.CompareTo(System.Object) +System.Int16.CopySign(System.Int16,System.Int16) +System.Int16.CreateChecked``1(``0) +System.Int16.CreateSaturating``1(``0) +System.Int16.CreateTruncating``1(``0) +System.Int16.DivRem(System.Int16,System.Int16) +System.Int16.Equals(System.Int16) +System.Int16.Equals(System.Object) +System.Int16.GetHashCode +System.Int16.GetTypeCode +System.Int16.IsEvenInteger(System.Int16) +System.Int16.IsNegative(System.Int16) +System.Int16.IsOddInteger(System.Int16) +System.Int16.IsPositive(System.Int16) +System.Int16.IsPow2(System.Int16) +System.Int16.LeadingZeroCount(System.Int16) +System.Int16.Log2(System.Int16) +System.Int16.Max(System.Int16,System.Int16) +System.Int16.MaxMagnitude(System.Int16,System.Int16) +System.Int16.MaxValue +System.Int16.Min(System.Int16,System.Int16) +System.Int16.MinMagnitude(System.Int16,System.Int16) +System.Int16.MinValue +System.Int16.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int16.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Int16.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int16.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int16.Parse(System.String) +System.Int16.Parse(System.String,System.Globalization.NumberStyles) +System.Int16.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Int16.Parse(System.String,System.IFormatProvider) +System.Int16.PopCount(System.Int16) +System.Int16.RotateLeft(System.Int16,System.Int32) +System.Int16.RotateRight(System.Int16,System.Int32) +System.Int16.Sign(System.Int16) +System.Int16.ToString +System.Int16.ToString(System.IFormatProvider) +System.Int16.ToString(System.String) +System.Int16.ToString(System.String,System.IFormatProvider) +System.Int16.TrailingZeroCount(System.Int16) +System.Int16.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int16.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) +System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int16@) +System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.Int16@) +System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) +System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int16@) +System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.Int16@) +System.Int16.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) +System.Int16.TryParse(System.String,System.IFormatProvider,System.Int16@) +System.Int16.TryParse(System.String,System.Int16@) +System.Int32 +System.Int32.Abs(System.Int32) +System.Int32.BigMul(System.Int32,System.Int32) +System.Int32.Clamp(System.Int32,System.Int32,System.Int32) +System.Int32.CompareTo(System.Int32) +System.Int32.CompareTo(System.Object) +System.Int32.CopySign(System.Int32,System.Int32) +System.Int32.CreateChecked``1(``0) +System.Int32.CreateSaturating``1(``0) +System.Int32.CreateTruncating``1(``0) +System.Int32.DivRem(System.Int32,System.Int32) +System.Int32.Equals(System.Int32) +System.Int32.Equals(System.Object) +System.Int32.GetHashCode +System.Int32.GetTypeCode +System.Int32.IsEvenInteger(System.Int32) +System.Int32.IsNegative(System.Int32) +System.Int32.IsOddInteger(System.Int32) +System.Int32.IsPositive(System.Int32) +System.Int32.IsPow2(System.Int32) +System.Int32.LeadingZeroCount(System.Int32) +System.Int32.Log2(System.Int32) +System.Int32.Max(System.Int32,System.Int32) +System.Int32.MaxMagnitude(System.Int32,System.Int32) +System.Int32.MaxValue +System.Int32.Min(System.Int32,System.Int32) +System.Int32.MinMagnitude(System.Int32,System.Int32) +System.Int32.MinValue +System.Int32.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int32.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Int32.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int32.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int32.Parse(System.String) +System.Int32.Parse(System.String,System.Globalization.NumberStyles) +System.Int32.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Int32.Parse(System.String,System.IFormatProvider) +System.Int32.PopCount(System.Int32) +System.Int32.RotateLeft(System.Int32,System.Int32) +System.Int32.RotateRight(System.Int32,System.Int32) +System.Int32.Sign(System.Int32) +System.Int32.ToString +System.Int32.ToString(System.IFormatProvider) +System.Int32.ToString(System.String) +System.Int32.ToString(System.String,System.IFormatProvider) +System.Int32.TrailingZeroCount(System.Int32) +System.Int32.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int32.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) +System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int32@) +System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.Int32@) +System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) +System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int32@) +System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.Int32@) +System.Int32.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) +System.Int32.TryParse(System.String,System.IFormatProvider,System.Int32@) +System.Int32.TryParse(System.String,System.Int32@) +System.Int64 +System.Int64.Abs(System.Int64) +System.Int64.BigMul(System.Int64,System.Int64) +System.Int64.Clamp(System.Int64,System.Int64,System.Int64) +System.Int64.CompareTo(System.Int64) +System.Int64.CompareTo(System.Object) +System.Int64.CopySign(System.Int64,System.Int64) +System.Int64.CreateChecked``1(``0) +System.Int64.CreateSaturating``1(``0) +System.Int64.CreateTruncating``1(``0) +System.Int64.DivRem(System.Int64,System.Int64) +System.Int64.Equals(System.Int64) +System.Int64.Equals(System.Object) +System.Int64.GetHashCode +System.Int64.GetTypeCode +System.Int64.IsEvenInteger(System.Int64) +System.Int64.IsNegative(System.Int64) +System.Int64.IsOddInteger(System.Int64) +System.Int64.IsPositive(System.Int64) +System.Int64.IsPow2(System.Int64) +System.Int64.LeadingZeroCount(System.Int64) +System.Int64.Log2(System.Int64) +System.Int64.Max(System.Int64,System.Int64) +System.Int64.MaxMagnitude(System.Int64,System.Int64) +System.Int64.MaxValue +System.Int64.Min(System.Int64,System.Int64) +System.Int64.MinMagnitude(System.Int64,System.Int64) +System.Int64.MinValue +System.Int64.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int64.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Int64.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Int64.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int64.Parse(System.String) +System.Int64.Parse(System.String,System.Globalization.NumberStyles) +System.Int64.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Int64.Parse(System.String,System.IFormatProvider) +System.Int64.PopCount(System.Int64) +System.Int64.RotateLeft(System.Int64,System.Int32) +System.Int64.RotateRight(System.Int64,System.Int32) +System.Int64.Sign(System.Int64) +System.Int64.ToString +System.Int64.ToString(System.IFormatProvider) +System.Int64.ToString(System.String) +System.Int64.ToString(System.String,System.IFormatProvider) +System.Int64.TrailingZeroCount(System.Int64) +System.Int64.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int64.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) +System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int64@) +System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.Int64@) +System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) +System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int64@) +System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.Int64@) +System.Int64.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) +System.Int64.TryParse(System.String,System.IFormatProvider,System.Int64@) +System.Int64.TryParse(System.String,System.Int64@) +System.IntPtr +System.IntPtr.#ctor(System.Int32) +System.IntPtr.#ctor(System.Int64) +System.IntPtr.#ctor(System.Void*) +System.IntPtr.Abs(System.IntPtr) +System.IntPtr.Add(System.IntPtr,System.Int32) +System.IntPtr.Clamp(System.IntPtr,System.IntPtr,System.IntPtr) +System.IntPtr.CompareTo(System.IntPtr) +System.IntPtr.CompareTo(System.Object) +System.IntPtr.CopySign(System.IntPtr,System.IntPtr) +System.IntPtr.CreateChecked``1(``0) +System.IntPtr.CreateSaturating``1(``0) +System.IntPtr.CreateTruncating``1(``0) +System.IntPtr.DivRem(System.IntPtr,System.IntPtr) +System.IntPtr.Equals(System.IntPtr) +System.IntPtr.Equals(System.Object) +System.IntPtr.GetHashCode +System.IntPtr.IsEvenInteger(System.IntPtr) +System.IntPtr.IsNegative(System.IntPtr) +System.IntPtr.IsOddInteger(System.IntPtr) +System.IntPtr.IsPositive(System.IntPtr) +System.IntPtr.IsPow2(System.IntPtr) +System.IntPtr.LeadingZeroCount(System.IntPtr) +System.IntPtr.Log2(System.IntPtr) +System.IntPtr.Max(System.IntPtr,System.IntPtr) +System.IntPtr.MaxMagnitude(System.IntPtr,System.IntPtr) +System.IntPtr.Min(System.IntPtr,System.IntPtr) +System.IntPtr.MinMagnitude(System.IntPtr,System.IntPtr) +System.IntPtr.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.IntPtr.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.IntPtr.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.IntPtr.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.IntPtr.Parse(System.String) +System.IntPtr.Parse(System.String,System.Globalization.NumberStyles) +System.IntPtr.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.IntPtr.Parse(System.String,System.IFormatProvider) +System.IntPtr.PopCount(System.IntPtr) +System.IntPtr.RotateLeft(System.IntPtr,System.Int32) +System.IntPtr.RotateRight(System.IntPtr,System.Int32) +System.IntPtr.Sign(System.IntPtr) +System.IntPtr.Subtract(System.IntPtr,System.Int32) +System.IntPtr.ToInt32 +System.IntPtr.ToInt64 +System.IntPtr.ToPointer +System.IntPtr.ToString +System.IntPtr.ToString(System.IFormatProvider) +System.IntPtr.ToString(System.String) +System.IntPtr.ToString(System.String,System.IFormatProvider) +System.IntPtr.TrailingZeroCount(System.IntPtr) +System.IntPtr.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.IntPtr.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) +System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.IntPtr@) +System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IntPtr@) +System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) +System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.IntPtr@) +System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IntPtr@) +System.IntPtr.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) +System.IntPtr.TryParse(System.String,System.IFormatProvider,System.IntPtr@) +System.IntPtr.TryParse(System.String,System.IntPtr@) +System.IntPtr.Zero +System.IntPtr.get_MaxValue +System.IntPtr.get_MinValue +System.IntPtr.get_Size +System.IntPtr.op_Addition(System.IntPtr,System.Int32) +System.IntPtr.op_Equality(System.IntPtr,System.IntPtr) +System.IntPtr.op_Explicit(System.Int32)~System.IntPtr +System.IntPtr.op_Explicit(System.Int64)~System.IntPtr +System.IntPtr.op_Explicit(System.IntPtr)~System.Int32 +System.IntPtr.op_Explicit(System.IntPtr)~System.Int64 +System.IntPtr.op_Explicit(System.IntPtr)~System.Void* +System.IntPtr.op_Explicit(System.Void*)~System.IntPtr +System.IntPtr.op_Inequality(System.IntPtr,System.IntPtr) +System.IntPtr.op_Subtraction(System.IntPtr,System.Int32) +System.InvalidCastException +System.InvalidCastException.#ctor +System.InvalidCastException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.InvalidCastException.#ctor(System.String) +System.InvalidCastException.#ctor(System.String,System.Exception) +System.InvalidCastException.#ctor(System.String,System.Int32) +System.InvalidOperationException +System.InvalidOperationException.#ctor +System.InvalidOperationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.InvalidOperationException.#ctor(System.String) +System.InvalidOperationException.#ctor(System.String,System.Exception) +System.InvalidProgramException +System.InvalidProgramException.#ctor +System.InvalidProgramException.#ctor(System.String) +System.InvalidProgramException.#ctor(System.String,System.Exception) +System.InvalidTimeZoneException +System.InvalidTimeZoneException.#ctor +System.InvalidTimeZoneException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.InvalidTimeZoneException.#ctor(System.String) +System.InvalidTimeZoneException.#ctor(System.String,System.Exception) +System.Lazy`1 +System.Lazy`1.#ctor +System.Lazy`1.#ctor(System.Boolean) +System.Lazy`1.#ctor(System.Func{`0}) +System.Lazy`1.#ctor(System.Func{`0},System.Boolean) +System.Lazy`1.#ctor(System.Func{`0},System.Threading.LazyThreadSafetyMode) +System.Lazy`1.#ctor(System.Threading.LazyThreadSafetyMode) +System.Lazy`1.#ctor(`0) +System.Lazy`1.ToString +System.Lazy`1.get_IsValueCreated +System.Lazy`1.get_Value +System.Lazy`2 +System.Lazy`2.#ctor(System.Func{`0},`1) +System.Lazy`2.#ctor(System.Func{`0},`1,System.Boolean) +System.Lazy`2.#ctor(System.Func{`0},`1,System.Threading.LazyThreadSafetyMode) +System.Lazy`2.#ctor(`1) +System.Lazy`2.#ctor(`1,System.Boolean) +System.Lazy`2.#ctor(`1,System.Threading.LazyThreadSafetyMode) +System.Lazy`2.get_Metadata +System.LdapStyleUriParser +System.LdapStyleUriParser.#ctor +System.Math +System.Math.Abs(System.Decimal) +System.Math.Abs(System.Double) +System.Math.Abs(System.Int16) +System.Math.Abs(System.Int32) +System.Math.Abs(System.Int64) +System.Math.Abs(System.IntPtr) +System.Math.Abs(System.SByte) +System.Math.Abs(System.Single) +System.Math.Acos(System.Double) +System.Math.Acosh(System.Double) +System.Math.Asin(System.Double) +System.Math.Asinh(System.Double) +System.Math.Atan(System.Double) +System.Math.Atan2(System.Double,System.Double) +System.Math.Atanh(System.Double) +System.Math.BigMul(System.Int32,System.Int32) +System.Math.BigMul(System.Int64,System.Int64) +System.Math.BigMul(System.Int64,System.Int64,System.Int64@) +System.Math.BigMul(System.UInt32,System.UInt32) +System.Math.BigMul(System.UInt64,System.UInt64) +System.Math.BigMul(System.UInt64,System.UInt64,System.UInt64@) +System.Math.BitDecrement(System.Double) +System.Math.BitIncrement(System.Double) +System.Math.Cbrt(System.Double) +System.Math.Ceiling(System.Decimal) +System.Math.Ceiling(System.Double) +System.Math.Clamp(System.Byte,System.Byte,System.Byte) +System.Math.Clamp(System.Decimal,System.Decimal,System.Decimal) +System.Math.Clamp(System.Double,System.Double,System.Double) +System.Math.Clamp(System.Int16,System.Int16,System.Int16) +System.Math.Clamp(System.Int32,System.Int32,System.Int32) +System.Math.Clamp(System.Int64,System.Int64,System.Int64) +System.Math.Clamp(System.IntPtr,System.IntPtr,System.IntPtr) +System.Math.Clamp(System.SByte,System.SByte,System.SByte) +System.Math.Clamp(System.Single,System.Single,System.Single) +System.Math.Clamp(System.UInt16,System.UInt16,System.UInt16) +System.Math.Clamp(System.UInt32,System.UInt32,System.UInt32) +System.Math.Clamp(System.UInt64,System.UInt64,System.UInt64) +System.Math.Clamp(System.UIntPtr,System.UIntPtr,System.UIntPtr) +System.Math.CopySign(System.Double,System.Double) +System.Math.Cos(System.Double) +System.Math.Cosh(System.Double) +System.Math.DivRem(System.Byte,System.Byte) +System.Math.DivRem(System.Int16,System.Int16) +System.Math.DivRem(System.Int32,System.Int32) +System.Math.DivRem(System.Int32,System.Int32,System.Int32@) +System.Math.DivRem(System.Int64,System.Int64) +System.Math.DivRem(System.Int64,System.Int64,System.Int64@) +System.Math.DivRem(System.IntPtr,System.IntPtr) +System.Math.DivRem(System.SByte,System.SByte) +System.Math.DivRem(System.UInt16,System.UInt16) +System.Math.DivRem(System.UInt32,System.UInt32) +System.Math.DivRem(System.UInt64,System.UInt64) +System.Math.DivRem(System.UIntPtr,System.UIntPtr) +System.Math.E +System.Math.Exp(System.Double) +System.Math.Floor(System.Decimal) +System.Math.Floor(System.Double) +System.Math.FusedMultiplyAdd(System.Double,System.Double,System.Double) +System.Math.IEEERemainder(System.Double,System.Double) +System.Math.ILogB(System.Double) +System.Math.Log(System.Double) +System.Math.Log(System.Double,System.Double) +System.Math.Log10(System.Double) +System.Math.Log2(System.Double) +System.Math.Max(System.Byte,System.Byte) +System.Math.Max(System.Decimal,System.Decimal) +System.Math.Max(System.Double,System.Double) +System.Math.Max(System.Int16,System.Int16) +System.Math.Max(System.Int32,System.Int32) +System.Math.Max(System.Int64,System.Int64) +System.Math.Max(System.IntPtr,System.IntPtr) +System.Math.Max(System.SByte,System.SByte) +System.Math.Max(System.Single,System.Single) +System.Math.Max(System.UInt16,System.UInt16) +System.Math.Max(System.UInt32,System.UInt32) +System.Math.Max(System.UInt64,System.UInt64) +System.Math.Max(System.UIntPtr,System.UIntPtr) +System.Math.MaxMagnitude(System.Double,System.Double) +System.Math.Min(System.Byte,System.Byte) +System.Math.Min(System.Decimal,System.Decimal) +System.Math.Min(System.Double,System.Double) +System.Math.Min(System.Int16,System.Int16) +System.Math.Min(System.Int32,System.Int32) +System.Math.Min(System.Int64,System.Int64) +System.Math.Min(System.IntPtr,System.IntPtr) +System.Math.Min(System.SByte,System.SByte) +System.Math.Min(System.Single,System.Single) +System.Math.Min(System.UInt16,System.UInt16) +System.Math.Min(System.UInt32,System.UInt32) +System.Math.Min(System.UInt64,System.UInt64) +System.Math.Min(System.UIntPtr,System.UIntPtr) +System.Math.MinMagnitude(System.Double,System.Double) +System.Math.PI +System.Math.Pow(System.Double,System.Double) +System.Math.ReciprocalEstimate(System.Double) +System.Math.ReciprocalSqrtEstimate(System.Double) +System.Math.Round(System.Decimal) +System.Math.Round(System.Decimal,System.Int32) +System.Math.Round(System.Decimal,System.Int32,System.MidpointRounding) +System.Math.Round(System.Decimal,System.MidpointRounding) +System.Math.Round(System.Double) +System.Math.Round(System.Double,System.Int32) +System.Math.Round(System.Double,System.Int32,System.MidpointRounding) +System.Math.Round(System.Double,System.MidpointRounding) +System.Math.ScaleB(System.Double,System.Int32) +System.Math.Sign(System.Decimal) +System.Math.Sign(System.Double) +System.Math.Sign(System.Int16) +System.Math.Sign(System.Int32) +System.Math.Sign(System.Int64) +System.Math.Sign(System.IntPtr) +System.Math.Sign(System.SByte) +System.Math.Sign(System.Single) +System.Math.Sin(System.Double) +System.Math.SinCos(System.Double) +System.Math.Sinh(System.Double) +System.Math.Sqrt(System.Double) +System.Math.Tan(System.Double) +System.Math.Tanh(System.Double) +System.Math.Tau +System.Math.Truncate(System.Decimal) +System.Math.Truncate(System.Double) +System.MathF +System.MathF.Abs(System.Single) +System.MathF.Acos(System.Single) +System.MathF.Acosh(System.Single) +System.MathF.Asin(System.Single) +System.MathF.Asinh(System.Single) +System.MathF.Atan(System.Single) +System.MathF.Atan2(System.Single,System.Single) +System.MathF.Atanh(System.Single) +System.MathF.BitDecrement(System.Single) +System.MathF.BitIncrement(System.Single) +System.MathF.Cbrt(System.Single) +System.MathF.Ceiling(System.Single) +System.MathF.CopySign(System.Single,System.Single) +System.MathF.Cos(System.Single) +System.MathF.Cosh(System.Single) +System.MathF.E +System.MathF.Exp(System.Single) +System.MathF.Floor(System.Single) +System.MathF.FusedMultiplyAdd(System.Single,System.Single,System.Single) +System.MathF.IEEERemainder(System.Single,System.Single) +System.MathF.ILogB(System.Single) +System.MathF.Log(System.Single) +System.MathF.Log(System.Single,System.Single) +System.MathF.Log10(System.Single) +System.MathF.Log2(System.Single) +System.MathF.Max(System.Single,System.Single) +System.MathF.MaxMagnitude(System.Single,System.Single) +System.MathF.Min(System.Single,System.Single) +System.MathF.MinMagnitude(System.Single,System.Single) +System.MathF.PI +System.MathF.Pow(System.Single,System.Single) +System.MathF.ReciprocalEstimate(System.Single) +System.MathF.ReciprocalSqrtEstimate(System.Single) +System.MathF.Round(System.Single) +System.MathF.Round(System.Single,System.Int32) +System.MathF.Round(System.Single,System.Int32,System.MidpointRounding) +System.MathF.Round(System.Single,System.MidpointRounding) +System.MathF.ScaleB(System.Single,System.Int32) +System.MathF.Sign(System.Single) +System.MathF.Sin(System.Single) +System.MathF.SinCos(System.Single) +System.MathF.Sinh(System.Single) +System.MathF.Sqrt(System.Single) +System.MathF.Tan(System.Single) +System.MathF.Tanh(System.Single) +System.MathF.Tau +System.MathF.Truncate(System.Single) +System.MemberAccessException +System.MemberAccessException.#ctor +System.MemberAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MemberAccessException.#ctor(System.String) +System.MemberAccessException.#ctor(System.String,System.Exception) +System.Memory`1 +System.Memory`1.#ctor(`0[]) +System.Memory`1.#ctor(`0[],System.Int32,System.Int32) +System.Memory`1.CopyTo(System.Memory{`0}) +System.Memory`1.Equals(System.Memory{`0}) +System.Memory`1.Equals(System.Object) +System.Memory`1.GetHashCode +System.Memory`1.Pin +System.Memory`1.Slice(System.Int32) +System.Memory`1.Slice(System.Int32,System.Int32) +System.Memory`1.ToArray +System.Memory`1.ToString +System.Memory`1.TryCopyTo(System.Memory{`0}) +System.Memory`1.get_Empty +System.Memory`1.get_IsEmpty +System.Memory`1.get_Length +System.Memory`1.get_Span +System.Memory`1.op_Implicit(System.ArraySegment{`0})~System.Memory{`0} +System.Memory`1.op_Implicit(System.Memory{`0})~System.ReadOnlyMemory{`0} +System.Memory`1.op_Implicit(`0[])~System.Memory{`0} +System.MethodAccessException +System.MethodAccessException.#ctor +System.MethodAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MethodAccessException.#ctor(System.String) +System.MethodAccessException.#ctor(System.String,System.Exception) +System.MidpointRounding +System.MidpointRounding.AwayFromZero +System.MidpointRounding.ToEven +System.MidpointRounding.ToNegativeInfinity +System.MidpointRounding.ToPositiveInfinity +System.MidpointRounding.ToZero +System.MissingFieldException +System.MissingFieldException.#ctor +System.MissingFieldException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MissingFieldException.#ctor(System.String) +System.MissingFieldException.#ctor(System.String,System.Exception) +System.MissingFieldException.#ctor(System.String,System.String) +System.MissingFieldException.get_Message +System.MissingMemberException +System.MissingMemberException.#ctor +System.MissingMemberException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MissingMemberException.#ctor(System.String) +System.MissingMemberException.#ctor(System.String,System.Exception) +System.MissingMemberException.#ctor(System.String,System.String) +System.MissingMemberException.ClassName +System.MissingMemberException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MissingMemberException.MemberName +System.MissingMemberException.Signature +System.MissingMemberException.get_Message +System.MissingMethodException +System.MissingMethodException.#ctor +System.MissingMethodException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MissingMethodException.#ctor(System.String) +System.MissingMethodException.#ctor(System.String,System.Exception) +System.MissingMethodException.#ctor(System.String,System.String) +System.MissingMethodException.get_Message +System.MulticastDelegate +System.MulticastDelegate.#ctor(System.Object,System.String) +System.MulticastDelegate.#ctor(System.Type,System.String) +System.MulticastDelegate.CombineImpl(System.Delegate) +System.MulticastDelegate.Equals(System.Object) +System.MulticastDelegate.GetHashCode +System.MulticastDelegate.GetInvocationList +System.MulticastDelegate.GetMethodImpl +System.MulticastDelegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.MulticastDelegate.RemoveImpl(System.Delegate) +System.MulticastDelegate.op_Equality(System.MulticastDelegate,System.MulticastDelegate) +System.MulticastDelegate.op_Inequality(System.MulticastDelegate,System.MulticastDelegate) +System.MulticastNotSupportedException +System.MulticastNotSupportedException.#ctor +System.MulticastNotSupportedException.#ctor(System.String) +System.MulticastNotSupportedException.#ctor(System.String,System.Exception) +System.NetPipeStyleUriParser +System.NetPipeStyleUriParser.#ctor +System.NetTcpStyleUriParser +System.NetTcpStyleUriParser.#ctor +System.NewsStyleUriParser +System.NewsStyleUriParser.#ctor +System.NonSerializedAttribute +System.NonSerializedAttribute.#ctor +System.NotFiniteNumberException +System.NotFiniteNumberException.#ctor +System.NotFiniteNumberException.#ctor(System.Double) +System.NotFiniteNumberException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.NotFiniteNumberException.#ctor(System.String) +System.NotFiniteNumberException.#ctor(System.String,System.Double) +System.NotFiniteNumberException.#ctor(System.String,System.Double,System.Exception) +System.NotFiniteNumberException.#ctor(System.String,System.Exception) +System.NotFiniteNumberException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.NotFiniteNumberException.get_OffendingNumber +System.NotImplementedException +System.NotImplementedException.#ctor +System.NotImplementedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.NotImplementedException.#ctor(System.String) +System.NotImplementedException.#ctor(System.String,System.Exception) +System.NotSupportedException +System.NotSupportedException.#ctor +System.NotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.NotSupportedException.#ctor(System.String) +System.NotSupportedException.#ctor(System.String,System.Exception) +System.NullReferenceException +System.NullReferenceException.#ctor +System.NullReferenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.NullReferenceException.#ctor(System.String) +System.NullReferenceException.#ctor(System.String,System.Exception) +System.Nullable +System.Nullable.Compare``1(System.Nullable{``0},System.Nullable{``0}) +System.Nullable.Equals``1(System.Nullable{``0},System.Nullable{``0}) +System.Nullable.GetUnderlyingType(System.Type) +System.Nullable.GetValueRefOrDefaultRef``1(System.Nullable{``0}@) +System.Nullable`1 +System.Nullable`1.#ctor(`0) +System.Nullable`1.Equals(System.Object) +System.Nullable`1.GetHashCode +System.Nullable`1.GetValueOrDefault +System.Nullable`1.GetValueOrDefault(`0) +System.Nullable`1.ToString +System.Nullable`1.get_HasValue +System.Nullable`1.get_Value +System.Nullable`1.op_Explicit(System.Nullable{`0})~`0 +System.Nullable`1.op_Implicit(`0)~System.Nullable{`0} +System.Numerics.BitOperations +System.Numerics.BitOperations.Crc32C(System.UInt32,System.Byte) +System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt16) +System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt32) +System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt64) +System.Numerics.BitOperations.IsPow2(System.Int32) +System.Numerics.BitOperations.IsPow2(System.Int64) +System.Numerics.BitOperations.IsPow2(System.IntPtr) +System.Numerics.BitOperations.IsPow2(System.UInt32) +System.Numerics.BitOperations.IsPow2(System.UInt64) +System.Numerics.BitOperations.IsPow2(System.UIntPtr) +System.Numerics.BitOperations.LeadingZeroCount(System.UInt32) +System.Numerics.BitOperations.LeadingZeroCount(System.UInt64) +System.Numerics.BitOperations.LeadingZeroCount(System.UIntPtr) +System.Numerics.BitOperations.Log2(System.UInt32) +System.Numerics.BitOperations.Log2(System.UInt64) +System.Numerics.BitOperations.Log2(System.UIntPtr) +System.Numerics.BitOperations.PopCount(System.UInt32) +System.Numerics.BitOperations.PopCount(System.UInt64) +System.Numerics.BitOperations.PopCount(System.UIntPtr) +System.Numerics.BitOperations.RotateLeft(System.UInt32,System.Int32) +System.Numerics.BitOperations.RotateLeft(System.UInt64,System.Int32) +System.Numerics.BitOperations.RotateLeft(System.UIntPtr,System.Int32) +System.Numerics.BitOperations.RotateRight(System.UInt32,System.Int32) +System.Numerics.BitOperations.RotateRight(System.UInt64,System.Int32) +System.Numerics.BitOperations.RotateRight(System.UIntPtr,System.Int32) +System.Numerics.BitOperations.RoundUpToPowerOf2(System.UInt32) +System.Numerics.BitOperations.RoundUpToPowerOf2(System.UInt64) +System.Numerics.BitOperations.RoundUpToPowerOf2(System.UIntPtr) +System.Numerics.BitOperations.TrailingZeroCount(System.Int32) +System.Numerics.BitOperations.TrailingZeroCount(System.Int64) +System.Numerics.BitOperations.TrailingZeroCount(System.IntPtr) +System.Numerics.BitOperations.TrailingZeroCount(System.UInt32) +System.Numerics.BitOperations.TrailingZeroCount(System.UInt64) +System.Numerics.BitOperations.TrailingZeroCount(System.UIntPtr) +System.Numerics.IAdditionOperators`3 +System.Numerics.IAdditionOperators`3.op_Addition(`0,`1) +System.Numerics.IAdditionOperators`3.op_CheckedAddition(`0,`1) +System.Numerics.IAdditiveIdentity`2 +System.Numerics.IAdditiveIdentity`2.get_AdditiveIdentity +System.Numerics.IBinaryFloatingPointIeee754`1 +System.Numerics.IBinaryInteger`1 +System.Numerics.IBinaryInteger`1.DivRem(`0,`0) +System.Numerics.IBinaryInteger`1.GetByteCount +System.Numerics.IBinaryInteger`1.GetShortestBitLength +System.Numerics.IBinaryInteger`1.LeadingZeroCount(`0) +System.Numerics.IBinaryInteger`1.PopCount(`0) +System.Numerics.IBinaryInteger`1.ReadBigEndian(System.Byte[],System.Boolean) +System.Numerics.IBinaryInteger`1.ReadBigEndian(System.Byte[],System.Int32,System.Boolean) +System.Numerics.IBinaryInteger`1.ReadBigEndian(System.ReadOnlySpan{System.Byte},System.Boolean) +System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.Byte[],System.Boolean) +System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.Byte[],System.Int32,System.Boolean) +System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.ReadOnlySpan{System.Byte},System.Boolean) +System.Numerics.IBinaryInteger`1.RotateLeft(`0,System.Int32) +System.Numerics.IBinaryInteger`1.RotateRight(`0,System.Int32) +System.Numerics.IBinaryInteger`1.TrailingZeroCount(`0) +System.Numerics.IBinaryInteger`1.TryReadBigEndian(System.ReadOnlySpan{System.Byte},System.Boolean,`0@) +System.Numerics.IBinaryInteger`1.TryReadLittleEndian(System.ReadOnlySpan{System.Byte},System.Boolean,`0@) +System.Numerics.IBinaryInteger`1.TryWriteBigEndian(System.Span{System.Byte},System.Int32@) +System.Numerics.IBinaryInteger`1.TryWriteLittleEndian(System.Span{System.Byte},System.Int32@) +System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Byte[]) +System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Byte[],System.Int32) +System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Span{System.Byte}) +System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Byte[]) +System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Byte[],System.Int32) +System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Span{System.Byte}) +System.Numerics.IBinaryNumber`1 +System.Numerics.IBinaryNumber`1.IsPow2(`0) +System.Numerics.IBinaryNumber`1.Log2(`0) +System.Numerics.IBinaryNumber`1.get_AllBitsSet +System.Numerics.IBitwiseOperators`3 +System.Numerics.IBitwiseOperators`3.op_BitwiseAnd(`0,`1) +System.Numerics.IBitwiseOperators`3.op_BitwiseOr(`0,`1) +System.Numerics.IBitwiseOperators`3.op_ExclusiveOr(`0,`1) +System.Numerics.IBitwiseOperators`3.op_OnesComplement(`0) +System.Numerics.IComparisonOperators`3 +System.Numerics.IComparisonOperators`3.op_GreaterThan(`0,`1) +System.Numerics.IComparisonOperators`3.op_GreaterThanOrEqual(`0,`1) +System.Numerics.IComparisonOperators`3.op_LessThan(`0,`1) +System.Numerics.IComparisonOperators`3.op_LessThanOrEqual(`0,`1) +System.Numerics.IDecrementOperators`1 +System.Numerics.IDecrementOperators`1.op_CheckedDecrement(`0) +System.Numerics.IDecrementOperators`1.op_Decrement(`0) +System.Numerics.IDivisionOperators`3 +System.Numerics.IDivisionOperators`3.op_CheckedDivision(`0,`1) +System.Numerics.IDivisionOperators`3.op_Division(`0,`1) +System.Numerics.IEqualityOperators`3 +System.Numerics.IEqualityOperators`3.op_Equality(`0,`1) +System.Numerics.IEqualityOperators`3.op_Inequality(`0,`1) +System.Numerics.IExponentialFunctions`1 +System.Numerics.IExponentialFunctions`1.Exp(`0) +System.Numerics.IExponentialFunctions`1.Exp10(`0) +System.Numerics.IExponentialFunctions`1.Exp10M1(`0) +System.Numerics.IExponentialFunctions`1.Exp2(`0) +System.Numerics.IExponentialFunctions`1.Exp2M1(`0) +System.Numerics.IExponentialFunctions`1.ExpM1(`0) +System.Numerics.IFloatingPointConstants`1 +System.Numerics.IFloatingPointConstants`1.get_E +System.Numerics.IFloatingPointConstants`1.get_Pi +System.Numerics.IFloatingPointConstants`1.get_Tau +System.Numerics.IFloatingPointIeee754`1 +System.Numerics.IFloatingPointIeee754`1.Atan2(`0,`0) +System.Numerics.IFloatingPointIeee754`1.Atan2Pi(`0,`0) +System.Numerics.IFloatingPointIeee754`1.BitDecrement(`0) +System.Numerics.IFloatingPointIeee754`1.BitIncrement(`0) +System.Numerics.IFloatingPointIeee754`1.FusedMultiplyAdd(`0,`0,`0) +System.Numerics.IFloatingPointIeee754`1.ILogB(`0) +System.Numerics.IFloatingPointIeee754`1.Ieee754Remainder(`0,`0) +System.Numerics.IFloatingPointIeee754`1.Lerp(`0,`0,`0) +System.Numerics.IFloatingPointIeee754`1.ReciprocalEstimate(`0) +System.Numerics.IFloatingPointIeee754`1.ReciprocalSqrtEstimate(`0) +System.Numerics.IFloatingPointIeee754`1.ScaleB(`0,System.Int32) +System.Numerics.IFloatingPointIeee754`1.get_Epsilon +System.Numerics.IFloatingPointIeee754`1.get_NaN +System.Numerics.IFloatingPointIeee754`1.get_NegativeInfinity +System.Numerics.IFloatingPointIeee754`1.get_NegativeZero +System.Numerics.IFloatingPointIeee754`1.get_PositiveInfinity +System.Numerics.IFloatingPoint`1 +System.Numerics.IFloatingPoint`1.Ceiling(`0) +System.Numerics.IFloatingPoint`1.ConvertToIntegerNative``1(`0) +System.Numerics.IFloatingPoint`1.ConvertToInteger``1(`0) +System.Numerics.IFloatingPoint`1.Floor(`0) +System.Numerics.IFloatingPoint`1.GetExponentByteCount +System.Numerics.IFloatingPoint`1.GetExponentShortestBitLength +System.Numerics.IFloatingPoint`1.GetSignificandBitLength +System.Numerics.IFloatingPoint`1.GetSignificandByteCount +System.Numerics.IFloatingPoint`1.Round(`0) +System.Numerics.IFloatingPoint`1.Round(`0,System.Int32) +System.Numerics.IFloatingPoint`1.Round(`0,System.Int32,System.MidpointRounding) +System.Numerics.IFloatingPoint`1.Round(`0,System.MidpointRounding) +System.Numerics.IFloatingPoint`1.Truncate(`0) +System.Numerics.IFloatingPoint`1.TryWriteExponentBigEndian(System.Span{System.Byte},System.Int32@) +System.Numerics.IFloatingPoint`1.TryWriteExponentLittleEndian(System.Span{System.Byte},System.Int32@) +System.Numerics.IFloatingPoint`1.TryWriteSignificandBigEndian(System.Span{System.Byte},System.Int32@) +System.Numerics.IFloatingPoint`1.TryWriteSignificandLittleEndian(System.Span{System.Byte},System.Int32@) +System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Byte[]) +System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Byte[],System.Int32) +System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Span{System.Byte}) +System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Byte[]) +System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Byte[],System.Int32) +System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Span{System.Byte}) +System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Byte[]) +System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Byte[],System.Int32) +System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Span{System.Byte}) +System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Byte[]) +System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Byte[],System.Int32) +System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Span{System.Byte}) +System.Numerics.IHyperbolicFunctions`1 +System.Numerics.IHyperbolicFunctions`1.Acosh(`0) +System.Numerics.IHyperbolicFunctions`1.Asinh(`0) +System.Numerics.IHyperbolicFunctions`1.Atanh(`0) +System.Numerics.IHyperbolicFunctions`1.Cosh(`0) +System.Numerics.IHyperbolicFunctions`1.Sinh(`0) +System.Numerics.IHyperbolicFunctions`1.Tanh(`0) +System.Numerics.IIncrementOperators`1 +System.Numerics.IIncrementOperators`1.op_CheckedIncrement(`0) +System.Numerics.IIncrementOperators`1.op_Increment(`0) +System.Numerics.ILogarithmicFunctions`1 +System.Numerics.ILogarithmicFunctions`1.Log(`0) +System.Numerics.ILogarithmicFunctions`1.Log(`0,`0) +System.Numerics.ILogarithmicFunctions`1.Log10(`0) +System.Numerics.ILogarithmicFunctions`1.Log10P1(`0) +System.Numerics.ILogarithmicFunctions`1.Log2(`0) +System.Numerics.ILogarithmicFunctions`1.Log2P1(`0) +System.Numerics.ILogarithmicFunctions`1.LogP1(`0) +System.Numerics.IMinMaxValue`1 +System.Numerics.IMinMaxValue`1.get_MaxValue +System.Numerics.IMinMaxValue`1.get_MinValue +System.Numerics.IModulusOperators`3 +System.Numerics.IModulusOperators`3.op_Modulus(`0,`1) +System.Numerics.IMultiplicativeIdentity`2 +System.Numerics.IMultiplicativeIdentity`2.get_MultiplicativeIdentity +System.Numerics.IMultiplyOperators`3 +System.Numerics.IMultiplyOperators`3.op_CheckedMultiply(`0,`1) +System.Numerics.IMultiplyOperators`3.op_Multiply(`0,`1) +System.Numerics.INumberBase`1 +System.Numerics.INumberBase`1.Abs(`0) +System.Numerics.INumberBase`1.CreateChecked``1(``0) +System.Numerics.INumberBase`1.CreateSaturating``1(``0) +System.Numerics.INumberBase`1.CreateTruncating``1(``0) +System.Numerics.INumberBase`1.IsCanonical(`0) +System.Numerics.INumberBase`1.IsComplexNumber(`0) +System.Numerics.INumberBase`1.IsEvenInteger(`0) +System.Numerics.INumberBase`1.IsFinite(`0) +System.Numerics.INumberBase`1.IsImaginaryNumber(`0) +System.Numerics.INumberBase`1.IsInfinity(`0) +System.Numerics.INumberBase`1.IsInteger(`0) +System.Numerics.INumberBase`1.IsNaN(`0) +System.Numerics.INumberBase`1.IsNegative(`0) +System.Numerics.INumberBase`1.IsNegativeInfinity(`0) +System.Numerics.INumberBase`1.IsNormal(`0) +System.Numerics.INumberBase`1.IsOddInteger(`0) +System.Numerics.INumberBase`1.IsPositive(`0) +System.Numerics.INumberBase`1.IsPositiveInfinity(`0) +System.Numerics.INumberBase`1.IsRealNumber(`0) +System.Numerics.INumberBase`1.IsSubnormal(`0) +System.Numerics.INumberBase`1.IsZero(`0) +System.Numerics.INumberBase`1.MaxMagnitude(`0,`0) +System.Numerics.INumberBase`1.MaxMagnitudeNumber(`0,`0) +System.Numerics.INumberBase`1.MinMagnitude(`0,`0) +System.Numerics.INumberBase`1.MinMagnitudeNumber(`0,`0) +System.Numerics.INumberBase`1.MultiplyAddEstimate(`0,`0,`0) +System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Numerics.INumberBase`1.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Numerics.INumberBase`1.TryConvertFromChecked``1(``0,`0@) +System.Numerics.INumberBase`1.TryConvertFromSaturating``1(``0,`0@) +System.Numerics.INumberBase`1.TryConvertFromTruncating``1(``0,`0@) +System.Numerics.INumberBase`1.TryConvertToChecked``1(`0,``0@) +System.Numerics.INumberBase`1.TryConvertToSaturating``1(`0,``0@) +System.Numerics.INumberBase`1.TryConvertToTruncating``1(`0,``0@) +System.Numerics.INumberBase`1.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,`0@) +System.Numerics.INumberBase`1.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,`0@) +System.Numerics.INumberBase`1.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,`0@) +System.Numerics.INumberBase`1.get_One +System.Numerics.INumberBase`1.get_Radix +System.Numerics.INumberBase`1.get_Zero +System.Numerics.INumber`1 +System.Numerics.INumber`1.Clamp(`0,`0,`0) +System.Numerics.INumber`1.CopySign(`0,`0) +System.Numerics.INumber`1.Max(`0,`0) +System.Numerics.INumber`1.MaxNumber(`0,`0) +System.Numerics.INumber`1.Min(`0,`0) +System.Numerics.INumber`1.MinNumber(`0,`0) +System.Numerics.INumber`1.Sign(`0) +System.Numerics.IPowerFunctions`1 +System.Numerics.IPowerFunctions`1.Pow(`0,`0) +System.Numerics.IRootFunctions`1 +System.Numerics.IRootFunctions`1.Cbrt(`0) +System.Numerics.IRootFunctions`1.Hypot(`0,`0) +System.Numerics.IRootFunctions`1.RootN(`0,System.Int32) +System.Numerics.IRootFunctions`1.Sqrt(`0) +System.Numerics.IShiftOperators`3 +System.Numerics.IShiftOperators`3.op_LeftShift(`0,`1) +System.Numerics.IShiftOperators`3.op_RightShift(`0,`1) +System.Numerics.IShiftOperators`3.op_UnsignedRightShift(`0,`1) +System.Numerics.ISignedNumber`1 +System.Numerics.ISignedNumber`1.get_NegativeOne +System.Numerics.ISubtractionOperators`3 +System.Numerics.ISubtractionOperators`3.op_CheckedSubtraction(`0,`1) +System.Numerics.ISubtractionOperators`3.op_Subtraction(`0,`1) +System.Numerics.ITrigonometricFunctions`1 +System.Numerics.ITrigonometricFunctions`1.Acos(`0) +System.Numerics.ITrigonometricFunctions`1.AcosPi(`0) +System.Numerics.ITrigonometricFunctions`1.Asin(`0) +System.Numerics.ITrigonometricFunctions`1.AsinPi(`0) +System.Numerics.ITrigonometricFunctions`1.Atan(`0) +System.Numerics.ITrigonometricFunctions`1.AtanPi(`0) +System.Numerics.ITrigonometricFunctions`1.Cos(`0) +System.Numerics.ITrigonometricFunctions`1.CosPi(`0) +System.Numerics.ITrigonometricFunctions`1.DegreesToRadians(`0) +System.Numerics.ITrigonometricFunctions`1.RadiansToDegrees(`0) +System.Numerics.ITrigonometricFunctions`1.Sin(`0) +System.Numerics.ITrigonometricFunctions`1.SinCos(`0) +System.Numerics.ITrigonometricFunctions`1.SinCosPi(`0) +System.Numerics.ITrigonometricFunctions`1.SinPi(`0) +System.Numerics.ITrigonometricFunctions`1.Tan(`0) +System.Numerics.ITrigonometricFunctions`1.TanPi(`0) +System.Numerics.IUnaryNegationOperators`2 +System.Numerics.IUnaryNegationOperators`2.op_CheckedUnaryNegation(`0) +System.Numerics.IUnaryNegationOperators`2.op_UnaryNegation(`0) +System.Numerics.IUnaryPlusOperators`2 +System.Numerics.IUnaryPlusOperators`2.op_UnaryPlus(`0) +System.Numerics.IUnsignedNumber`1 +System.Numerics.TotalOrderIeee754Comparer`1 +System.Numerics.TotalOrderIeee754Comparer`1.Compare(`0,`0) +System.Numerics.TotalOrderIeee754Comparer`1.Equals(System.Numerics.TotalOrderIeee754Comparer{`0}) +System.Numerics.TotalOrderIeee754Comparer`1.Equals(System.Object) +System.Numerics.TotalOrderIeee754Comparer`1.Equals(`0,`0) +System.Numerics.TotalOrderIeee754Comparer`1.GetHashCode +System.Numerics.TotalOrderIeee754Comparer`1.GetHashCode(`0) +System.Object +System.Object.#ctor +System.Object.Equals(System.Object) +System.Object.Equals(System.Object,System.Object) +System.Object.Finalize +System.Object.GetHashCode +System.Object.GetType +System.Object.MemberwiseClone +System.Object.ReferenceEquals(System.Object,System.Object) +System.Object.ToString +System.ObjectDisposedException +System.ObjectDisposedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ObjectDisposedException.#ctor(System.String) +System.ObjectDisposedException.#ctor(System.String,System.Exception) +System.ObjectDisposedException.#ctor(System.String,System.String) +System.ObjectDisposedException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.ObjectDisposedException.ThrowIf(System.Boolean,System.Object) +System.ObjectDisposedException.ThrowIf(System.Boolean,System.Type) +System.ObjectDisposedException.get_Message +System.ObjectDisposedException.get_ObjectName +System.ObsoleteAttribute +System.ObsoleteAttribute.#ctor +System.ObsoleteAttribute.#ctor(System.String) +System.ObsoleteAttribute.#ctor(System.String,System.Boolean) +System.ObsoleteAttribute.get_DiagnosticId +System.ObsoleteAttribute.get_IsError +System.ObsoleteAttribute.get_Message +System.ObsoleteAttribute.get_UrlFormat +System.ObsoleteAttribute.set_DiagnosticId(System.String) +System.ObsoleteAttribute.set_UrlFormat(System.String) +System.OperatingSystem +System.OperatingSystem.#ctor(System.PlatformID,System.Version) +System.OperatingSystem.Clone +System.OperatingSystem.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.OperatingSystem.IsAndroid +System.OperatingSystem.IsAndroidVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsBrowser +System.OperatingSystem.IsFreeBSD +System.OperatingSystem.IsFreeBSDVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsIOS +System.OperatingSystem.IsIOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsLinux +System.OperatingSystem.IsMacCatalyst +System.OperatingSystem.IsMacCatalystVersionAtLeast(System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsMacOS +System.OperatingSystem.IsMacOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsOSPlatform(System.String) +System.OperatingSystem.IsOSPlatformVersionAtLeast(System.String,System.Int32,System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsTvOS +System.OperatingSystem.IsTvOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsWasi +System.OperatingSystem.IsWatchOS +System.OperatingSystem.IsWatchOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +System.OperatingSystem.IsWindows +System.OperatingSystem.IsWindowsVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) +System.OperatingSystem.ToString +System.OperatingSystem.get_Platform +System.OperatingSystem.get_ServicePack +System.OperatingSystem.get_Version +System.OperatingSystem.get_VersionString +System.OperationCanceledException +System.OperationCanceledException.#ctor +System.OperationCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.OperationCanceledException.#ctor(System.String) +System.OperationCanceledException.#ctor(System.String,System.Exception) +System.OperationCanceledException.#ctor(System.String,System.Exception,System.Threading.CancellationToken) +System.OperationCanceledException.#ctor(System.String,System.Threading.CancellationToken) +System.OperationCanceledException.#ctor(System.Threading.CancellationToken) +System.OperationCanceledException.get_CancellationToken +System.OutOfMemoryException +System.OutOfMemoryException.#ctor +System.OutOfMemoryException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.OutOfMemoryException.#ctor(System.String) +System.OutOfMemoryException.#ctor(System.String,System.Exception) +System.OverflowException +System.OverflowException.#ctor +System.OverflowException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.OverflowException.#ctor(System.String) +System.OverflowException.#ctor(System.String,System.Exception) +System.ParamArrayAttribute +System.ParamArrayAttribute.#ctor +System.PlatformID +System.PlatformID.MacOSX +System.PlatformID.Other +System.PlatformID.Unix +System.PlatformID.Win32NT +System.PlatformID.Win32S +System.PlatformID.Win32Windows +System.PlatformID.WinCE +System.PlatformID.Xbox +System.PlatformNotSupportedException +System.PlatformNotSupportedException.#ctor +System.PlatformNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.PlatformNotSupportedException.#ctor(System.String) +System.PlatformNotSupportedException.#ctor(System.String,System.Exception) +System.Predicate`1 +System.Predicate`1.#ctor(System.Object,System.IntPtr) +System.Predicate`1.BeginInvoke(`0,System.AsyncCallback,System.Object) +System.Predicate`1.EndInvoke(System.IAsyncResult) +System.Predicate`1.Invoke(`0) +System.Progress`1 +System.Progress`1.#ctor +System.Progress`1.#ctor(System.Action{`0}) +System.Progress`1.OnReport(`0) +System.Progress`1.add_ProgressChanged(System.EventHandler{`0}) +System.Progress`1.remove_ProgressChanged(System.EventHandler{`0}) +System.Random +System.Random.#ctor +System.Random.#ctor(System.Int32) +System.Random.GetItems``1(System.ReadOnlySpan{``0},System.Int32) +System.Random.GetItems``1(System.ReadOnlySpan{``0},System.Span{``0}) +System.Random.GetItems``1(``0[],System.Int32) +System.Random.Next +System.Random.Next(System.Int32) +System.Random.Next(System.Int32,System.Int32) +System.Random.NextBytes(System.Byte[]) +System.Random.NextBytes(System.Span{System.Byte}) +System.Random.NextDouble +System.Random.NextInt64 +System.Random.NextInt64(System.Int64) +System.Random.NextInt64(System.Int64,System.Int64) +System.Random.NextSingle +System.Random.Sample +System.Random.Shuffle``1(System.Span{``0}) +System.Random.Shuffle``1(``0[]) +System.Random.get_Shared +System.Range +System.Range.#ctor(System.Index,System.Index) +System.Range.EndAt(System.Index) +System.Range.Equals(System.Object) +System.Range.Equals(System.Range) +System.Range.GetHashCode +System.Range.GetOffsetAndLength(System.Int32) +System.Range.StartAt(System.Index) +System.Range.ToString +System.Range.get_All +System.Range.get_End +System.Range.get_Start +System.RankException +System.RankException.#ctor +System.RankException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.RankException.#ctor(System.String) +System.RankException.#ctor(System.String,System.Exception) +System.ReadOnlyMemory`1 +System.ReadOnlyMemory`1.#ctor(`0[]) +System.ReadOnlyMemory`1.#ctor(`0[],System.Int32,System.Int32) +System.ReadOnlyMemory`1.CopyTo(System.Memory{`0}) +System.ReadOnlyMemory`1.Equals(System.Object) +System.ReadOnlyMemory`1.Equals(System.ReadOnlyMemory{`0}) +System.ReadOnlyMemory`1.GetHashCode +System.ReadOnlyMemory`1.Pin +System.ReadOnlyMemory`1.Slice(System.Int32) +System.ReadOnlyMemory`1.Slice(System.Int32,System.Int32) +System.ReadOnlyMemory`1.ToArray +System.ReadOnlyMemory`1.ToString +System.ReadOnlyMemory`1.TryCopyTo(System.Memory{`0}) +System.ReadOnlyMemory`1.get_Empty +System.ReadOnlyMemory`1.get_IsEmpty +System.ReadOnlyMemory`1.get_Length +System.ReadOnlyMemory`1.get_Span +System.ReadOnlyMemory`1.op_Implicit(System.ArraySegment{`0})~System.ReadOnlyMemory{`0} +System.ReadOnlyMemory`1.op_Implicit(`0[])~System.ReadOnlyMemory{`0} +System.ReadOnlySpan`1 +System.ReadOnlySpan`1.#ctor(System.Void*,System.Int32) +System.ReadOnlySpan`1.#ctor(`0@) +System.ReadOnlySpan`1.#ctor(`0[]) +System.ReadOnlySpan`1.#ctor(`0[],System.Int32,System.Int32) +System.ReadOnlySpan`1.CastUp``1(System.ReadOnlySpan{``0}) +System.ReadOnlySpan`1.CopyTo(System.Span{`0}) +System.ReadOnlySpan`1.Enumerator +System.ReadOnlySpan`1.Enumerator.MoveNext +System.ReadOnlySpan`1.Enumerator.get_Current +System.ReadOnlySpan`1.Equals(System.Object) +System.ReadOnlySpan`1.GetEnumerator +System.ReadOnlySpan`1.GetHashCode +System.ReadOnlySpan`1.GetPinnableReference +System.ReadOnlySpan`1.Slice(System.Int32) +System.ReadOnlySpan`1.Slice(System.Int32,System.Int32) +System.ReadOnlySpan`1.ToArray +System.ReadOnlySpan`1.ToString +System.ReadOnlySpan`1.TryCopyTo(System.Span{`0}) +System.ReadOnlySpan`1.get_Empty +System.ReadOnlySpan`1.get_IsEmpty +System.ReadOnlySpan`1.get_Item(System.Int32) +System.ReadOnlySpan`1.get_Length +System.ReadOnlySpan`1.op_Equality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0}) +System.ReadOnlySpan`1.op_Implicit(System.ArraySegment{`0})~System.ReadOnlySpan{`0} +System.ReadOnlySpan`1.op_Implicit(`0[])~System.ReadOnlySpan{`0} +System.ReadOnlySpan`1.op_Inequality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0}) +System.ResolveEventArgs +System.ResolveEventArgs.#ctor(System.String) +System.ResolveEventArgs.#ctor(System.String,System.Reflection.Assembly) +System.ResolveEventArgs.get_Name +System.ResolveEventArgs.get_RequestingAssembly +System.ResolveEventHandler +System.ResolveEventHandler.#ctor(System.Object,System.IntPtr) +System.ResolveEventHandler.BeginInvoke(System.Object,System.ResolveEventArgs,System.AsyncCallback,System.Object) +System.ResolveEventHandler.EndInvoke(System.IAsyncResult) +System.ResolveEventHandler.Invoke(System.Object,System.ResolveEventArgs) +System.Runtime.CompilerServices.AccessedThroughPropertyAttribute +System.Runtime.CompilerServices.AccessedThroughPropertyAttribute.#ctor(System.String) +System.Runtime.CompilerServices.AccessedThroughPropertyAttribute.get_PropertyName +System.Runtime.CompilerServices.AsyncIteratorMethodBuilder +System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete +System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Create +System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.MoveNext``1(``0@) +System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute +System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute.#ctor(System.Type) +System.Runtime.CompilerServices.AsyncMethodBuilderAttribute +System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.#ctor(System.Type) +System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.get_BuilderType +System.Runtime.CompilerServices.AsyncStateMachineAttribute +System.Runtime.CompilerServices.AsyncStateMachineAttribute.#ctor(System.Type) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start``1(``0@) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder.get_Task +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(System.Exception) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetResult(`0) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start``1(``0@) +System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.Create +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetException(System.Exception) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetResult +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.Start``1(``0@) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.get_Task +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetException(System.Exception) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetResult(`0) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start``1(``0@) +System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task +System.Runtime.CompilerServices.AsyncVoidMethodBuilder +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetException(System.Exception) +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetResult +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Start``1(``0@) +System.Runtime.CompilerServices.CallConvCdecl +System.Runtime.CompilerServices.CallConvCdecl.#ctor +System.Runtime.CompilerServices.CallConvFastcall +System.Runtime.CompilerServices.CallConvFastcall.#ctor +System.Runtime.CompilerServices.CallConvMemberFunction +System.Runtime.CompilerServices.CallConvMemberFunction.#ctor +System.Runtime.CompilerServices.CallConvStdcall +System.Runtime.CompilerServices.CallConvStdcall.#ctor +System.Runtime.CompilerServices.CallConvSuppressGCTransition +System.Runtime.CompilerServices.CallConvSuppressGCTransition.#ctor +System.Runtime.CompilerServices.CallConvSwift +System.Runtime.CompilerServices.CallConvSwift.#ctor +System.Runtime.CompilerServices.CallConvThiscall +System.Runtime.CompilerServices.CallConvThiscall.#ctor +System.Runtime.CompilerServices.CallerArgumentExpressionAttribute +System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.#ctor(System.String) +System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.get_ParameterName +System.Runtime.CompilerServices.CallerFilePathAttribute +System.Runtime.CompilerServices.CallerFilePathAttribute.#ctor +System.Runtime.CompilerServices.CallerLineNumberAttribute +System.Runtime.CompilerServices.CallerLineNumberAttribute.#ctor +System.Runtime.CompilerServices.CallerMemberNameAttribute +System.Runtime.CompilerServices.CallerMemberNameAttribute.#ctor +System.Runtime.CompilerServices.CollectionBuilderAttribute +System.Runtime.CompilerServices.CollectionBuilderAttribute.#ctor(System.Type,System.String) +System.Runtime.CompilerServices.CollectionBuilderAttribute.get_BuilderType +System.Runtime.CompilerServices.CollectionBuilderAttribute.get_MethodName +System.Runtime.CompilerServices.CompilationRelaxations +System.Runtime.CompilerServices.CompilationRelaxations.NoStringInterning +System.Runtime.CompilerServices.CompilationRelaxationsAttribute +System.Runtime.CompilerServices.CompilationRelaxationsAttribute.#ctor(System.Int32) +System.Runtime.CompilerServices.CompilationRelaxationsAttribute.#ctor(System.Runtime.CompilerServices.CompilationRelaxations) +System.Runtime.CompilerServices.CompilationRelaxationsAttribute.get_CompilationRelaxations +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.#ctor(System.String) +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.RefStructs +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.RequiredMembers +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.get_FeatureName +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.get_IsOptional +System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.set_IsOptional(System.Boolean) +System.Runtime.CompilerServices.CompilerGeneratedAttribute +System.Runtime.CompilerServices.CompilerGeneratedAttribute.#ctor +System.Runtime.CompilerServices.CompilerGlobalScopeAttribute +System.Runtime.CompilerServices.CompilerGlobalScopeAttribute.#ctor +System.Runtime.CompilerServices.ConditionalWeakTable`2 +System.Runtime.CompilerServices.ConditionalWeakTable`2.#ctor +System.Runtime.CompilerServices.ConditionalWeakTable`2.Add(`0,`1) +System.Runtime.CompilerServices.ConditionalWeakTable`2.AddOrUpdate(`0,`1) +System.Runtime.CompilerServices.ConditionalWeakTable`2.Clear +System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback +System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.#ctor(System.Object,System.IntPtr) +System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.BeginInvoke(`0,System.AsyncCallback,System.Object) +System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.EndInvoke(System.IAsyncResult) +System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.Invoke(`0) +System.Runtime.CompilerServices.ConditionalWeakTable`2.GetOrCreateValue(`0) +System.Runtime.CompilerServices.ConditionalWeakTable`2.GetValue(`0,System.Runtime.CompilerServices.ConditionalWeakTable{`0,`1}.CreateValueCallback) +System.Runtime.CompilerServices.ConditionalWeakTable`2.Remove(`0) +System.Runtime.CompilerServices.ConditionalWeakTable`2.TryAdd(`0,`1) +System.Runtime.CompilerServices.ConditionalWeakTable`2.TryGetValue(`0,`1@) +System.Runtime.CompilerServices.ConfiguredAsyncDisposable +System.Runtime.CompilerServices.ConfiguredAsyncDisposable.DisposeAsync +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1 +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.ConfigureAwait(System.Boolean) +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.DisposeAsync +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.MoveNextAsync +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.get_Current +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.GetAsyncEnumerator +System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.WithCancellation(System.Threading.CancellationToken) +System.Runtime.CompilerServices.ConfiguredTaskAwaitable +System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter +System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.GetResult +System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.get_IsCompleted +System.Runtime.CompilerServices.ConfiguredTaskAwaitable.GetAwaiter +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1 +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.GetResult +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.get_IsCompleted +System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.GetAwaiter +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.GetResult +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.get_IsCompleted +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.GetAwaiter +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1 +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.GetResult +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.get_IsCompleted +System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.GetAwaiter +System.Runtime.CompilerServices.CustomConstantAttribute +System.Runtime.CompilerServices.CustomConstantAttribute.#ctor +System.Runtime.CompilerServices.CustomConstantAttribute.get_Value +System.Runtime.CompilerServices.DateTimeConstantAttribute +System.Runtime.CompilerServices.DateTimeConstantAttribute.#ctor(System.Int64) +System.Runtime.CompilerServices.DateTimeConstantAttribute.get_Value +System.Runtime.CompilerServices.DecimalConstantAttribute +System.Runtime.CompilerServices.DecimalConstantAttribute.#ctor(System.Byte,System.Byte,System.Int32,System.Int32,System.Int32) +System.Runtime.CompilerServices.DecimalConstantAttribute.#ctor(System.Byte,System.Byte,System.UInt32,System.UInt32,System.UInt32) +System.Runtime.CompilerServices.DecimalConstantAttribute.get_Value +System.Runtime.CompilerServices.DefaultDependencyAttribute +System.Runtime.CompilerServices.DefaultDependencyAttribute.#ctor(System.Runtime.CompilerServices.LoadHint) +System.Runtime.CompilerServices.DefaultDependencyAttribute.get_LoadHint +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.IFormatProvider) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.IFormatProvider,System.Span{System.Char}) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(System.String) +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToString +System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear +System.Runtime.CompilerServices.DependencyAttribute +System.Runtime.CompilerServices.DependencyAttribute.#ctor(System.String,System.Runtime.CompilerServices.LoadHint) +System.Runtime.CompilerServices.DependencyAttribute.get_DependentAssembly +System.Runtime.CompilerServices.DependencyAttribute.get_LoadHint +System.Runtime.CompilerServices.DisablePrivateReflectionAttribute +System.Runtime.CompilerServices.DisablePrivateReflectionAttribute.#ctor +System.Runtime.CompilerServices.DisableRuntimeMarshallingAttribute +System.Runtime.CompilerServices.DisableRuntimeMarshallingAttribute.#ctor +System.Runtime.CompilerServices.DiscardableAttribute +System.Runtime.CompilerServices.DiscardableAttribute.#ctor +System.Runtime.CompilerServices.EnumeratorCancellationAttribute +System.Runtime.CompilerServices.EnumeratorCancellationAttribute.#ctor +System.Runtime.CompilerServices.ExtensionAttribute +System.Runtime.CompilerServices.ExtensionAttribute.#ctor +System.Runtime.CompilerServices.FixedAddressValueTypeAttribute +System.Runtime.CompilerServices.FixedAddressValueTypeAttribute.#ctor +System.Runtime.CompilerServices.FixedBufferAttribute +System.Runtime.CompilerServices.FixedBufferAttribute.#ctor(System.Type,System.Int32) +System.Runtime.CompilerServices.FixedBufferAttribute.get_ElementType +System.Runtime.CompilerServices.FixedBufferAttribute.get_Length +System.Runtime.CompilerServices.FormattableStringFactory +System.Runtime.CompilerServices.FormattableStringFactory.Create(System.String,System.Object[]) +System.Runtime.CompilerServices.IAsyncStateMachine +System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext +System.Runtime.CompilerServices.IAsyncStateMachine.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.ICriticalNotifyCompletion +System.Runtime.CompilerServices.ICriticalNotifyCompletion.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.INotifyCompletion +System.Runtime.CompilerServices.INotifyCompletion.OnCompleted(System.Action) +System.Runtime.CompilerServices.IStrongBox +System.Runtime.CompilerServices.IStrongBox.get_Value +System.Runtime.CompilerServices.IStrongBox.set_Value(System.Object) +System.Runtime.CompilerServices.ITuple +System.Runtime.CompilerServices.ITuple.get_Item(System.Int32) +System.Runtime.CompilerServices.ITuple.get_Length +System.Runtime.CompilerServices.IndexerNameAttribute +System.Runtime.CompilerServices.IndexerNameAttribute.#ctor(System.String) +System.Runtime.CompilerServices.InlineArrayAttribute +System.Runtime.CompilerServices.InlineArrayAttribute.#ctor(System.Int32) +System.Runtime.CompilerServices.InlineArrayAttribute.get_Length +System.Runtime.CompilerServices.InternalsVisibleToAttribute +System.Runtime.CompilerServices.InternalsVisibleToAttribute.#ctor(System.String) +System.Runtime.CompilerServices.InternalsVisibleToAttribute.get_AllInternalsVisible +System.Runtime.CompilerServices.InternalsVisibleToAttribute.get_AssemblyName +System.Runtime.CompilerServices.InternalsVisibleToAttribute.set_AllInternalsVisible(System.Boolean) +System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute +System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.#ctor(System.String) +System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.#ctor(System.String[]) +System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.get_Arguments +System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute +System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute.#ctor +System.Runtime.CompilerServices.IsByRefLikeAttribute +System.Runtime.CompilerServices.IsByRefLikeAttribute.#ctor +System.Runtime.CompilerServices.IsConst +System.Runtime.CompilerServices.IsExternalInit +System.Runtime.CompilerServices.IsReadOnlyAttribute +System.Runtime.CompilerServices.IsReadOnlyAttribute.#ctor +System.Runtime.CompilerServices.IsUnmanagedAttribute +System.Runtime.CompilerServices.IsUnmanagedAttribute.#ctor +System.Runtime.CompilerServices.IsVolatile +System.Runtime.CompilerServices.IteratorStateMachineAttribute +System.Runtime.CompilerServices.IteratorStateMachineAttribute.#ctor(System.Type) +System.Runtime.CompilerServices.LoadHint +System.Runtime.CompilerServices.LoadHint.Always +System.Runtime.CompilerServices.LoadHint.Default +System.Runtime.CompilerServices.LoadHint.Sometimes +System.Runtime.CompilerServices.MethodCodeType +System.Runtime.CompilerServices.MethodCodeType.IL +System.Runtime.CompilerServices.MethodCodeType.Native +System.Runtime.CompilerServices.MethodCodeType.OPTIL +System.Runtime.CompilerServices.MethodCodeType.Runtime +System.Runtime.CompilerServices.MethodImplAttribute +System.Runtime.CompilerServices.MethodImplAttribute.#ctor +System.Runtime.CompilerServices.MethodImplAttribute.#ctor(System.Int16) +System.Runtime.CompilerServices.MethodImplAttribute.#ctor(System.Runtime.CompilerServices.MethodImplOptions) +System.Runtime.CompilerServices.MethodImplAttribute.MethodCodeType +System.Runtime.CompilerServices.MethodImplAttribute.get_Value +System.Runtime.CompilerServices.ModuleInitializerAttribute +System.Runtime.CompilerServices.ModuleInitializerAttribute.#ctor +System.Runtime.CompilerServices.NullableAttribute +System.Runtime.CompilerServices.NullableAttribute.#ctor(System.Byte) +System.Runtime.CompilerServices.NullableAttribute.#ctor(System.Byte[]) +System.Runtime.CompilerServices.NullableAttribute.NullableFlags +System.Runtime.CompilerServices.NullableContextAttribute +System.Runtime.CompilerServices.NullableContextAttribute.#ctor(System.Byte) +System.Runtime.CompilerServices.NullableContextAttribute.Flag +System.Runtime.CompilerServices.NullablePublicOnlyAttribute +System.Runtime.CompilerServices.NullablePublicOnlyAttribute.#ctor(System.Boolean) +System.Runtime.CompilerServices.NullablePublicOnlyAttribute.IncludesInternals +System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute +System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute.#ctor(System.Int32) +System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute.get_Priority +System.Runtime.CompilerServices.ParamCollectionAttribute +System.Runtime.CompilerServices.ParamCollectionAttribute.#ctor +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.Create +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetException(System.Exception) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetResult +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.Start``1(``0@) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.get_Task +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1 +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.Create +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetException(System.Exception) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetResult(`0) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.Start``1(``0@) +System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.get_Task +System.Runtime.CompilerServices.PreserveBaseOverridesAttribute +System.Runtime.CompilerServices.PreserveBaseOverridesAttribute.#ctor +System.Runtime.CompilerServices.RefSafetyRulesAttribute +System.Runtime.CompilerServices.RefSafetyRulesAttribute.#ctor(System.Int32) +System.Runtime.CompilerServices.RefSafetyRulesAttribute.get_Version +System.Runtime.CompilerServices.ReferenceAssemblyAttribute +System.Runtime.CompilerServices.ReferenceAssemblyAttribute.#ctor +System.Runtime.CompilerServices.ReferenceAssemblyAttribute.#ctor(System.String) +System.Runtime.CompilerServices.ReferenceAssemblyAttribute.get_Description +System.Runtime.CompilerServices.RequiredMemberAttribute +System.Runtime.CompilerServices.RequiredMemberAttribute.#ctor +System.Runtime.CompilerServices.RequiresLocationAttribute +System.Runtime.CompilerServices.RequiresLocationAttribute.#ctor +System.Runtime.CompilerServices.RuntimeCompatibilityAttribute +System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.#ctor +System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.get_WrapNonExceptionThrows +System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.set_WrapNonExceptionThrows(System.Boolean) +System.Runtime.CompilerServices.RuntimeFeature +System.Runtime.CompilerServices.RuntimeFeature.ByRefFields +System.Runtime.CompilerServices.RuntimeFeature.ByRefLikeGenerics +System.Runtime.CompilerServices.RuntimeFeature.CovariantReturnsOfClasses +System.Runtime.CompilerServices.RuntimeFeature.DefaultImplementationsOfInterfaces +System.Runtime.CompilerServices.RuntimeFeature.IsSupported(System.String) +System.Runtime.CompilerServices.RuntimeFeature.NumericIntPtr +System.Runtime.CompilerServices.RuntimeFeature.PortablePdb +System.Runtime.CompilerServices.RuntimeFeature.UnmanagedSignatureCallingConvention +System.Runtime.CompilerServices.RuntimeFeature.VirtualStaticsInInterfaces +System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeCompiled +System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeSupported +System.Runtime.CompilerServices.RuntimeHelpers +System.Runtime.CompilerServices.RuntimeHelpers.AllocateTypeAssociatedMemory(System.Type,System.Int32) +System.Runtime.CompilerServices.RuntimeHelpers.Box(System.Byte@,System.RuntimeTypeHandle) +System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode +System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.#ctor(System.Object,System.IntPtr) +System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.BeginInvoke(System.Object,System.Boolean,System.AsyncCallback,System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.EndInvoke(System.IAsyncResult) +System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.Invoke(System.Object,System.Boolean) +System.Runtime.CompilerServices.RuntimeHelpers.CreateSpan``1(System.RuntimeFieldHandle) +System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack +System.Runtime.CompilerServices.RuntimeHelpers.Equals(System.Object,System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(System.Runtime.CompilerServices.RuntimeHelpers.TryCode,System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode,System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.GetSubArray``1(``0[],System.Range) +System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(System.Type) +System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray(System.Array,System.RuntimeFieldHandle) +System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences``1 +System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions +System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegionsNoOP +System.Runtime.CompilerServices.RuntimeHelpers.PrepareContractedDelegate(System.Delegate) +System.Runtime.CompilerServices.RuntimeHelpers.PrepareDelegate(System.Delegate) +System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMethodHandle) +System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMethodHandle,System.RuntimeTypeHandle[]) +System.Runtime.CompilerServices.RuntimeHelpers.ProbeForSufficientStack +System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(System.RuntimeTypeHandle) +System.Runtime.CompilerServices.RuntimeHelpers.RunModuleConstructor(System.ModuleHandle) +System.Runtime.CompilerServices.RuntimeHelpers.SizeOf(System.RuntimeTypeHandle) +System.Runtime.CompilerServices.RuntimeHelpers.TryCode +System.Runtime.CompilerServices.RuntimeHelpers.TryCode.#ctor(System.Object,System.IntPtr) +System.Runtime.CompilerServices.RuntimeHelpers.TryCode.BeginInvoke(System.Object,System.AsyncCallback,System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.TryCode.EndInvoke(System.IAsyncResult) +System.Runtime.CompilerServices.RuntimeHelpers.TryCode.Invoke(System.Object) +System.Runtime.CompilerServices.RuntimeHelpers.TryEnsureSufficientExecutionStack +System.Runtime.CompilerServices.RuntimeHelpers.get_OffsetToStringData +System.Runtime.CompilerServices.RuntimeWrappedException +System.Runtime.CompilerServices.RuntimeWrappedException.#ctor(System.Object) +System.Runtime.CompilerServices.RuntimeWrappedException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Runtime.CompilerServices.RuntimeWrappedException.get_WrappedException +System.Runtime.CompilerServices.ScopedRefAttribute +System.Runtime.CompilerServices.ScopedRefAttribute.#ctor +System.Runtime.CompilerServices.SkipLocalsInitAttribute +System.Runtime.CompilerServices.SkipLocalsInitAttribute.#ctor +System.Runtime.CompilerServices.SpecialNameAttribute +System.Runtime.CompilerServices.SpecialNameAttribute.#ctor +System.Runtime.CompilerServices.StateMachineAttribute +System.Runtime.CompilerServices.StateMachineAttribute.#ctor(System.Type) +System.Runtime.CompilerServices.StateMachineAttribute.get_StateMachineType +System.Runtime.CompilerServices.StringFreezingAttribute +System.Runtime.CompilerServices.StringFreezingAttribute.#ctor +System.Runtime.CompilerServices.StrongBox`1 +System.Runtime.CompilerServices.StrongBox`1.#ctor +System.Runtime.CompilerServices.StrongBox`1.#ctor(`0) +System.Runtime.CompilerServices.StrongBox`1.Value +System.Runtime.CompilerServices.SuppressIldasmAttribute +System.Runtime.CompilerServices.SuppressIldasmAttribute.#ctor +System.Runtime.CompilerServices.SwitchExpressionException +System.Runtime.CompilerServices.SwitchExpressionException.#ctor +System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.Exception) +System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.Object) +System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.String) +System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.String,System.Exception) +System.Runtime.CompilerServices.SwitchExpressionException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Runtime.CompilerServices.SwitchExpressionException.get_Message +System.Runtime.CompilerServices.SwitchExpressionException.get_UnmatchedValue +System.Runtime.CompilerServices.TaskAwaiter +System.Runtime.CompilerServices.TaskAwaiter.GetResult +System.Runtime.CompilerServices.TaskAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.TaskAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.TaskAwaiter.get_IsCompleted +System.Runtime.CompilerServices.TaskAwaiter`1 +System.Runtime.CompilerServices.TaskAwaiter`1.GetResult +System.Runtime.CompilerServices.TaskAwaiter`1.OnCompleted(System.Action) +System.Runtime.CompilerServices.TaskAwaiter`1.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.TaskAwaiter`1.get_IsCompleted +System.Runtime.CompilerServices.TupleElementNamesAttribute +System.Runtime.CompilerServices.TupleElementNamesAttribute.#ctor(System.String[]) +System.Runtime.CompilerServices.TupleElementNamesAttribute.get_TransformNames +System.Runtime.CompilerServices.TypeForwardedFromAttribute +System.Runtime.CompilerServices.TypeForwardedFromAttribute.#ctor(System.String) +System.Runtime.CompilerServices.TypeForwardedFromAttribute.get_AssemblyFullName +System.Runtime.CompilerServices.TypeForwardedToAttribute +System.Runtime.CompilerServices.TypeForwardedToAttribute.#ctor(System.Type) +System.Runtime.CompilerServices.TypeForwardedToAttribute.get_Destination +System.Runtime.CompilerServices.Unsafe +System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.IntPtr) +System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.UIntPtr) +System.Runtime.CompilerServices.Unsafe.Add``1(System.Void*,System.Int32) +System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.Int32) +System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.IntPtr) +System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.UIntPtr) +System.Runtime.CompilerServices.Unsafe.AreSame``1(``0@,``0@) +System.Runtime.CompilerServices.Unsafe.AsPointer``1(``0@) +System.Runtime.CompilerServices.Unsafe.AsRef``1(System.Void*) +System.Runtime.CompilerServices.Unsafe.AsRef``1(``0@) +System.Runtime.CompilerServices.Unsafe.As``1(System.Object) +System.Runtime.CompilerServices.Unsafe.As``2(``0@) +System.Runtime.CompilerServices.Unsafe.BitCast``2(``0) +System.Runtime.CompilerServices.Unsafe.ByteOffset``1(``0@,``0@) +System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Byte@,System.Byte@,System.UInt32) +System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Void*,System.Void*,System.UInt32) +System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Byte@,System.Byte@,System.UInt32) +System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Void*,System.Void*,System.UInt32) +System.Runtime.CompilerServices.Unsafe.Copy``1(System.Void*,``0@) +System.Runtime.CompilerServices.Unsafe.Copy``1(``0@,System.Void*) +System.Runtime.CompilerServices.Unsafe.InitBlock(System.Byte@,System.Byte,System.UInt32) +System.Runtime.CompilerServices.Unsafe.InitBlock(System.Void*,System.Byte,System.UInt32) +System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Byte@,System.Byte,System.UInt32) +System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Void*,System.Byte,System.UInt32) +System.Runtime.CompilerServices.Unsafe.IsAddressGreaterThan``1(``0@,``0@) +System.Runtime.CompilerServices.Unsafe.IsAddressLessThan``1(``0@,``0@) +System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@) +System.Runtime.CompilerServices.Unsafe.NullRef``1 +System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Byte@) +System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Void*) +System.Runtime.CompilerServices.Unsafe.Read``1(System.Void*) +System.Runtime.CompilerServices.Unsafe.SizeOf``1 +System.Runtime.CompilerServices.Unsafe.SkipInit``1(``0@) +System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.IntPtr) +System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.UIntPtr) +System.Runtime.CompilerServices.Unsafe.Subtract``1(System.Void*,System.Int32) +System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.Int32) +System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.IntPtr) +System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.UIntPtr) +System.Runtime.CompilerServices.Unsafe.Unbox``1(System.Object) +System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Byte@,``0) +System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Void*,``0) +System.Runtime.CompilerServices.Unsafe.Write``1(System.Void*,``0) +System.Runtime.CompilerServices.UnsafeAccessorAttribute +System.Runtime.CompilerServices.UnsafeAccessorAttribute.#ctor(System.Runtime.CompilerServices.UnsafeAccessorKind) +System.Runtime.CompilerServices.UnsafeAccessorAttribute.get_Kind +System.Runtime.CompilerServices.UnsafeAccessorAttribute.get_Name +System.Runtime.CompilerServices.UnsafeAccessorAttribute.set_Name(System.String) +System.Runtime.CompilerServices.UnsafeAccessorKind +System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor +System.Runtime.CompilerServices.UnsafeAccessorKind.Field +System.Runtime.CompilerServices.UnsafeAccessorKind.Method +System.Runtime.CompilerServices.UnsafeAccessorKind.StaticField +System.Runtime.CompilerServices.UnsafeAccessorKind.StaticMethod +System.Runtime.CompilerServices.UnsafeValueTypeAttribute +System.Runtime.CompilerServices.UnsafeValueTypeAttribute.#ctor +System.Runtime.CompilerServices.ValueTaskAwaiter +System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult +System.Runtime.CompilerServices.ValueTaskAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.ValueTaskAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.ValueTaskAwaiter.get_IsCompleted +System.Runtime.CompilerServices.ValueTaskAwaiter`1 +System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult +System.Runtime.CompilerServices.ValueTaskAwaiter`1.OnCompleted(System.Action) +System.Runtime.CompilerServices.ValueTaskAwaiter`1.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.ValueTaskAwaiter`1.get_IsCompleted +System.Runtime.CompilerServices.YieldAwaitable +System.Runtime.CompilerServices.YieldAwaitable.GetAwaiter +System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter +System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.GetResult +System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.OnCompleted(System.Action) +System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.UnsafeOnCompleted(System.Action) +System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.get_IsCompleted +System.RuntimeArgumentHandle +System.RuntimeFieldHandle +System.RuntimeFieldHandle.Equals(System.Object) +System.RuntimeFieldHandle.Equals(System.RuntimeFieldHandle) +System.RuntimeFieldHandle.FromIntPtr(System.IntPtr) +System.RuntimeFieldHandle.GetHashCode +System.RuntimeFieldHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.RuntimeFieldHandle.ToIntPtr(System.RuntimeFieldHandle) +System.RuntimeFieldHandle.get_Value +System.RuntimeFieldHandle.op_Equality(System.RuntimeFieldHandle,System.RuntimeFieldHandle) +System.RuntimeFieldHandle.op_Inequality(System.RuntimeFieldHandle,System.RuntimeFieldHandle) +System.RuntimeMethodHandle +System.RuntimeMethodHandle.Equals(System.Object) +System.RuntimeMethodHandle.Equals(System.RuntimeMethodHandle) +System.RuntimeMethodHandle.FromIntPtr(System.IntPtr) +System.RuntimeMethodHandle.GetFunctionPointer +System.RuntimeMethodHandle.GetHashCode +System.RuntimeMethodHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.RuntimeMethodHandle.ToIntPtr(System.RuntimeMethodHandle) +System.RuntimeMethodHandle.get_Value +System.RuntimeMethodHandle.op_Equality(System.RuntimeMethodHandle,System.RuntimeMethodHandle) +System.RuntimeMethodHandle.op_Inequality(System.RuntimeMethodHandle,System.RuntimeMethodHandle) +System.RuntimeTypeHandle +System.RuntimeTypeHandle.Equals(System.Object) +System.RuntimeTypeHandle.Equals(System.RuntimeTypeHandle) +System.RuntimeTypeHandle.FromIntPtr(System.IntPtr) +System.RuntimeTypeHandle.GetHashCode +System.RuntimeTypeHandle.GetModuleHandle +System.RuntimeTypeHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.RuntimeTypeHandle.ToIntPtr(System.RuntimeTypeHandle) +System.RuntimeTypeHandle.get_Value +System.RuntimeTypeHandle.op_Equality(System.Object,System.RuntimeTypeHandle) +System.RuntimeTypeHandle.op_Equality(System.RuntimeTypeHandle,System.Object) +System.RuntimeTypeHandle.op_Inequality(System.Object,System.RuntimeTypeHandle) +System.RuntimeTypeHandle.op_Inequality(System.RuntimeTypeHandle,System.Object) +System.SByte +System.SByte.Abs(System.SByte) +System.SByte.Clamp(System.SByte,System.SByte,System.SByte) +System.SByte.CompareTo(System.Object) +System.SByte.CompareTo(System.SByte) +System.SByte.CopySign(System.SByte,System.SByte) +System.SByte.CreateChecked``1(``0) +System.SByte.CreateSaturating``1(``0) +System.SByte.CreateTruncating``1(``0) +System.SByte.DivRem(System.SByte,System.SByte) +System.SByte.Equals(System.Object) +System.SByte.Equals(System.SByte) +System.SByte.GetHashCode +System.SByte.GetTypeCode +System.SByte.IsEvenInteger(System.SByte) +System.SByte.IsNegative(System.SByte) +System.SByte.IsOddInteger(System.SByte) +System.SByte.IsPositive(System.SByte) +System.SByte.IsPow2(System.SByte) +System.SByte.LeadingZeroCount(System.SByte) +System.SByte.Log2(System.SByte) +System.SByte.Max(System.SByte,System.SByte) +System.SByte.MaxMagnitude(System.SByte,System.SByte) +System.SByte.MaxValue +System.SByte.Min(System.SByte,System.SByte) +System.SByte.MinMagnitude(System.SByte,System.SByte) +System.SByte.MinValue +System.SByte.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.SByte.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.SByte.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.SByte.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.SByte.Parse(System.String) +System.SByte.Parse(System.String,System.Globalization.NumberStyles) +System.SByte.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.SByte.Parse(System.String,System.IFormatProvider) +System.SByte.PopCount(System.SByte) +System.SByte.RotateLeft(System.SByte,System.Int32) +System.SByte.RotateRight(System.SByte,System.Int32) +System.SByte.Sign(System.SByte) +System.SByte.ToString +System.SByte.ToString(System.IFormatProvider) +System.SByte.ToString(System.String) +System.SByte.ToString(System.String,System.IFormatProvider) +System.SByte.TrailingZeroCount(System.SByte) +System.SByte.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.SByte.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) +System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.SByte@) +System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.SByte@) +System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) +System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.SByte@) +System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.SByte@) +System.SByte.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) +System.SByte.TryParse(System.String,System.IFormatProvider,System.SByte@) +System.SByte.TryParse(System.String,System.SByte@) +System.SerializableAttribute +System.SerializableAttribute.#ctor +System.Single +System.Single.Abs(System.Single) +System.Single.Acos(System.Single) +System.Single.AcosPi(System.Single) +System.Single.Acosh(System.Single) +System.Single.Asin(System.Single) +System.Single.AsinPi(System.Single) +System.Single.Asinh(System.Single) +System.Single.Atan(System.Single) +System.Single.Atan2(System.Single,System.Single) +System.Single.Atan2Pi(System.Single,System.Single) +System.Single.AtanPi(System.Single) +System.Single.Atanh(System.Single) +System.Single.BitDecrement(System.Single) +System.Single.BitIncrement(System.Single) +System.Single.Cbrt(System.Single) +System.Single.Ceiling(System.Single) +System.Single.Clamp(System.Single,System.Single,System.Single) +System.Single.CompareTo(System.Object) +System.Single.CompareTo(System.Single) +System.Single.ConvertToIntegerNative``1(System.Single) +System.Single.ConvertToInteger``1(System.Single) +System.Single.CopySign(System.Single,System.Single) +System.Single.Cos(System.Single) +System.Single.CosPi(System.Single) +System.Single.Cosh(System.Single) +System.Single.CreateChecked``1(``0) +System.Single.CreateSaturating``1(``0) +System.Single.CreateTruncating``1(``0) +System.Single.DegreesToRadians(System.Single) +System.Single.E +System.Single.Epsilon +System.Single.Equals(System.Object) +System.Single.Equals(System.Single) +System.Single.Exp(System.Single) +System.Single.Exp10(System.Single) +System.Single.Exp10M1(System.Single) +System.Single.Exp2(System.Single) +System.Single.Exp2M1(System.Single) +System.Single.ExpM1(System.Single) +System.Single.Floor(System.Single) +System.Single.FusedMultiplyAdd(System.Single,System.Single,System.Single) +System.Single.GetHashCode +System.Single.GetTypeCode +System.Single.Hypot(System.Single,System.Single) +System.Single.ILogB(System.Single) +System.Single.Ieee754Remainder(System.Single,System.Single) +System.Single.IsEvenInteger(System.Single) +System.Single.IsFinite(System.Single) +System.Single.IsInfinity(System.Single) +System.Single.IsInteger(System.Single) +System.Single.IsNaN(System.Single) +System.Single.IsNegative(System.Single) +System.Single.IsNegativeInfinity(System.Single) +System.Single.IsNormal(System.Single) +System.Single.IsOddInteger(System.Single) +System.Single.IsPositive(System.Single) +System.Single.IsPositiveInfinity(System.Single) +System.Single.IsPow2(System.Single) +System.Single.IsRealNumber(System.Single) +System.Single.IsSubnormal(System.Single) +System.Single.Lerp(System.Single,System.Single,System.Single) +System.Single.Log(System.Single) +System.Single.Log(System.Single,System.Single) +System.Single.Log10(System.Single) +System.Single.Log10P1(System.Single) +System.Single.Log2(System.Single) +System.Single.Log2P1(System.Single) +System.Single.LogP1(System.Single) +System.Single.Max(System.Single,System.Single) +System.Single.MaxMagnitude(System.Single,System.Single) +System.Single.MaxMagnitudeNumber(System.Single,System.Single) +System.Single.MaxNumber(System.Single,System.Single) +System.Single.MaxValue +System.Single.Min(System.Single,System.Single) +System.Single.MinMagnitude(System.Single,System.Single) +System.Single.MinMagnitudeNumber(System.Single,System.Single) +System.Single.MinNumber(System.Single,System.Single) +System.Single.MinValue +System.Single.MultiplyAddEstimate(System.Single,System.Single,System.Single) +System.Single.NaN +System.Single.NegativeInfinity +System.Single.NegativeZero +System.Single.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.Single.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.Single.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.Single.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Single.Parse(System.String) +System.Single.Parse(System.String,System.Globalization.NumberStyles) +System.Single.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.Single.Parse(System.String,System.IFormatProvider) +System.Single.Pi +System.Single.PositiveInfinity +System.Single.Pow(System.Single,System.Single) +System.Single.RadiansToDegrees(System.Single) +System.Single.ReciprocalEstimate(System.Single) +System.Single.ReciprocalSqrtEstimate(System.Single) +System.Single.RootN(System.Single,System.Int32) +System.Single.Round(System.Single) +System.Single.Round(System.Single,System.Int32) +System.Single.Round(System.Single,System.Int32,System.MidpointRounding) +System.Single.Round(System.Single,System.MidpointRounding) +System.Single.ScaleB(System.Single,System.Int32) +System.Single.Sign(System.Single) +System.Single.Sin(System.Single) +System.Single.SinCos(System.Single) +System.Single.SinCosPi(System.Single) +System.Single.SinPi(System.Single) +System.Single.Sinh(System.Single) +System.Single.Sqrt(System.Single) +System.Single.Tan(System.Single) +System.Single.TanPi(System.Single) +System.Single.Tanh(System.Single) +System.Single.Tau +System.Single.ToString +System.Single.ToString(System.IFormatProvider) +System.Single.ToString(System.String) +System.Single.ToString(System.String,System.IFormatProvider) +System.Single.Truncate(System.Single) +System.Single.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Single.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) +System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Single@) +System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.Single@) +System.Single.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) +System.Single.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Single@) +System.Single.TryParse(System.ReadOnlySpan{System.Char},System.Single@) +System.Single.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) +System.Single.TryParse(System.String,System.IFormatProvider,System.Single@) +System.Single.TryParse(System.String,System.Single@) +System.Single.op_Equality(System.Single,System.Single) +System.Single.op_GreaterThan(System.Single,System.Single) +System.Single.op_GreaterThanOrEqual(System.Single,System.Single) +System.Single.op_Inequality(System.Single,System.Single) +System.Single.op_LessThan(System.Single,System.Single) +System.Single.op_LessThanOrEqual(System.Single,System.Single) +System.Span`1 +System.Span`1.#ctor(System.Void*,System.Int32) +System.Span`1.#ctor(`0@) +System.Span`1.#ctor(`0[]) +System.Span`1.#ctor(`0[],System.Int32,System.Int32) +System.Span`1.Clear +System.Span`1.CopyTo(System.Span{`0}) +System.Span`1.Enumerator +System.Span`1.Enumerator.MoveNext +System.Span`1.Enumerator.get_Current +System.Span`1.Equals(System.Object) +System.Span`1.Fill(`0) +System.Span`1.GetEnumerator +System.Span`1.GetHashCode +System.Span`1.GetPinnableReference +System.Span`1.Slice(System.Int32) +System.Span`1.Slice(System.Int32,System.Int32) +System.Span`1.ToArray +System.Span`1.ToString +System.Span`1.TryCopyTo(System.Span{`0}) +System.Span`1.get_Empty +System.Span`1.get_IsEmpty +System.Span`1.get_Item(System.Int32) +System.Span`1.get_Length +System.Span`1.op_Equality(System.Span{`0},System.Span{`0}) +System.Span`1.op_Implicit(System.ArraySegment{`0})~System.Span{`0} +System.Span`1.op_Implicit(System.Span{`0})~System.ReadOnlySpan{`0} +System.Span`1.op_Implicit(`0[])~System.Span{`0} +System.Span`1.op_Inequality(System.Span{`0},System.Span{`0}) +System.StackOverflowException +System.StackOverflowException.#ctor +System.StackOverflowException.#ctor(System.String) +System.StackOverflowException.#ctor(System.String,System.Exception) +System.String +System.String.#ctor(System.Char*) +System.String.#ctor(System.Char*,System.Int32,System.Int32) +System.String.#ctor(System.Char,System.Int32) +System.String.#ctor(System.Char[]) +System.String.#ctor(System.Char[],System.Int32,System.Int32) +System.String.#ctor(System.ReadOnlySpan{System.Char}) +System.String.#ctor(System.SByte*) +System.String.#ctor(System.SByte*,System.Int32,System.Int32) +System.String.#ctor(System.SByte*,System.Int32,System.Int32,System.Text.Encoding) +System.String.Clone +System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32) +System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean) +System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean,System.Globalization.CultureInfo) +System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CultureInfo,System.Globalization.CompareOptions) +System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.StringComparison) +System.String.Compare(System.String,System.String) +System.String.Compare(System.String,System.String,System.Boolean) +System.String.Compare(System.String,System.String,System.Boolean,System.Globalization.CultureInfo) +System.String.Compare(System.String,System.String,System.Globalization.CultureInfo,System.Globalization.CompareOptions) +System.String.Compare(System.String,System.String,System.StringComparison) +System.String.CompareOrdinal(System.String,System.Int32,System.String,System.Int32,System.Int32) +System.String.CompareOrdinal(System.String,System.String) +System.String.CompareTo(System.Object) +System.String.CompareTo(System.String) +System.String.Concat(System.Collections.Generic.IEnumerable{System.String}) +System.String.Concat(System.Object) +System.String.Concat(System.Object,System.Object) +System.String.Concat(System.Object,System.Object,System.Object) +System.String.Concat(System.Object[]) +System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.String.Concat(System.ReadOnlySpan{System.Object}) +System.String.Concat(System.ReadOnlySpan{System.String}) +System.String.Concat(System.String,System.String) +System.String.Concat(System.String,System.String,System.String) +System.String.Concat(System.String,System.String,System.String,System.String) +System.String.Concat(System.String[]) +System.String.Concat``1(System.Collections.Generic.IEnumerable{``0}) +System.String.Contains(System.Char) +System.String.Contains(System.Char,System.StringComparison) +System.String.Contains(System.String) +System.String.Contains(System.String,System.StringComparison) +System.String.Copy(System.String) +System.String.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) +System.String.CopyTo(System.Span{System.Char}) +System.String.Create(System.IFormatProvider,System.Runtime.CompilerServices.DefaultInterpolatedStringHandler@) +System.String.Create(System.IFormatProvider,System.Span{System.Char},System.Runtime.CompilerServices.DefaultInterpolatedStringHandler@) +System.String.Create``1(System.Int32,``0,System.Buffers.SpanAction{System.Char,``0}) +System.String.Empty +System.String.EndsWith(System.Char) +System.String.EndsWith(System.String) +System.String.EndsWith(System.String,System.Boolean,System.Globalization.CultureInfo) +System.String.EndsWith(System.String,System.StringComparison) +System.String.EnumerateRunes +System.String.Equals(System.Object) +System.String.Equals(System.String) +System.String.Equals(System.String,System.String) +System.String.Equals(System.String,System.String,System.StringComparison) +System.String.Equals(System.String,System.StringComparison) +System.String.Format(System.IFormatProvider,System.String,System.Object) +System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object) +System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) +System.String.Format(System.IFormatProvider,System.String,System.Object[]) +System.String.Format(System.IFormatProvider,System.String,System.ReadOnlySpan{System.Object}) +System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) +System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) +System.String.Format(System.String,System.Object) +System.String.Format(System.String,System.Object,System.Object) +System.String.Format(System.String,System.Object,System.Object,System.Object) +System.String.Format(System.String,System.Object[]) +System.String.Format(System.String,System.ReadOnlySpan{System.Object}) +System.String.Format``1(System.IFormatProvider,System.Text.CompositeFormat,``0) +System.String.Format``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) +System.String.Format``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) +System.String.GetEnumerator +System.String.GetHashCode +System.String.GetHashCode(System.ReadOnlySpan{System.Char}) +System.String.GetHashCode(System.ReadOnlySpan{System.Char},System.StringComparison) +System.String.GetHashCode(System.StringComparison) +System.String.GetPinnableReference +System.String.GetTypeCode +System.String.IndexOf(System.Char) +System.String.IndexOf(System.Char,System.Int32) +System.String.IndexOf(System.Char,System.Int32,System.Int32) +System.String.IndexOf(System.Char,System.StringComparison) +System.String.IndexOf(System.String) +System.String.IndexOf(System.String,System.Int32) +System.String.IndexOf(System.String,System.Int32,System.Int32) +System.String.IndexOf(System.String,System.Int32,System.Int32,System.StringComparison) +System.String.IndexOf(System.String,System.Int32,System.StringComparison) +System.String.IndexOf(System.String,System.StringComparison) +System.String.IndexOfAny(System.Char[]) +System.String.IndexOfAny(System.Char[],System.Int32) +System.String.IndexOfAny(System.Char[],System.Int32,System.Int32) +System.String.Insert(System.Int32,System.String) +System.String.Intern(System.String) +System.String.IsInterned(System.String) +System.String.IsNormalized +System.String.IsNormalized(System.Text.NormalizationForm) +System.String.IsNullOrEmpty(System.String) +System.String.IsNullOrWhiteSpace(System.String) +System.String.Join(System.Char,System.Object[]) +System.String.Join(System.Char,System.ReadOnlySpan{System.Object}) +System.String.Join(System.Char,System.ReadOnlySpan{System.String}) +System.String.Join(System.Char,System.String[]) +System.String.Join(System.Char,System.String[],System.Int32,System.Int32) +System.String.Join(System.String,System.Collections.Generic.IEnumerable{System.String}) +System.String.Join(System.String,System.Object[]) +System.String.Join(System.String,System.ReadOnlySpan{System.Object}) +System.String.Join(System.String,System.ReadOnlySpan{System.String}) +System.String.Join(System.String,System.String[]) +System.String.Join(System.String,System.String[],System.Int32,System.Int32) +System.String.Join``1(System.Char,System.Collections.Generic.IEnumerable{``0}) +System.String.Join``1(System.String,System.Collections.Generic.IEnumerable{``0}) +System.String.LastIndexOf(System.Char) +System.String.LastIndexOf(System.Char,System.Int32) +System.String.LastIndexOf(System.Char,System.Int32,System.Int32) +System.String.LastIndexOf(System.String) +System.String.LastIndexOf(System.String,System.Int32) +System.String.LastIndexOf(System.String,System.Int32,System.Int32) +System.String.LastIndexOf(System.String,System.Int32,System.Int32,System.StringComparison) +System.String.LastIndexOf(System.String,System.Int32,System.StringComparison) +System.String.LastIndexOf(System.String,System.StringComparison) +System.String.LastIndexOfAny(System.Char[]) +System.String.LastIndexOfAny(System.Char[],System.Int32) +System.String.LastIndexOfAny(System.Char[],System.Int32,System.Int32) +System.String.Normalize +System.String.Normalize(System.Text.NormalizationForm) +System.String.PadLeft(System.Int32) +System.String.PadLeft(System.Int32,System.Char) +System.String.PadRight(System.Int32) +System.String.PadRight(System.Int32,System.Char) +System.String.Remove(System.Int32) +System.String.Remove(System.Int32,System.Int32) +System.String.Replace(System.Char,System.Char) +System.String.Replace(System.String,System.String) +System.String.Replace(System.String,System.String,System.Boolean,System.Globalization.CultureInfo) +System.String.Replace(System.String,System.String,System.StringComparison) +System.String.ReplaceLineEndings +System.String.ReplaceLineEndings(System.String) +System.String.Split(System.Char,System.Int32,System.StringSplitOptions) +System.String.Split(System.Char,System.StringSplitOptions) +System.String.Split(System.Char[]) +System.String.Split(System.Char[],System.Int32) +System.String.Split(System.Char[],System.Int32,System.StringSplitOptions) +System.String.Split(System.Char[],System.StringSplitOptions) +System.String.Split(System.ReadOnlySpan{System.Char}) +System.String.Split(System.String,System.Int32,System.StringSplitOptions) +System.String.Split(System.String,System.StringSplitOptions) +System.String.Split(System.String[],System.Int32,System.StringSplitOptions) +System.String.Split(System.String[],System.StringSplitOptions) +System.String.StartsWith(System.Char) +System.String.StartsWith(System.String) +System.String.StartsWith(System.String,System.Boolean,System.Globalization.CultureInfo) +System.String.StartsWith(System.String,System.StringComparison) +System.String.Substring(System.Int32) +System.String.Substring(System.Int32,System.Int32) +System.String.ToCharArray +System.String.ToCharArray(System.Int32,System.Int32) +System.String.ToLower +System.String.ToLower(System.Globalization.CultureInfo) +System.String.ToLowerInvariant +System.String.ToString +System.String.ToString(System.IFormatProvider) +System.String.ToUpper +System.String.ToUpper(System.Globalization.CultureInfo) +System.String.ToUpperInvariant +System.String.Trim +System.String.Trim(System.Char) +System.String.Trim(System.Char[]) +System.String.TrimEnd +System.String.TrimEnd(System.Char) +System.String.TrimEnd(System.Char[]) +System.String.TrimStart +System.String.TrimStart(System.Char) +System.String.TrimStart(System.Char[]) +System.String.TryCopyTo(System.Span{System.Char}) +System.String.get_Chars(System.Int32) +System.String.get_Length +System.String.op_Equality(System.String,System.String) +System.String.op_Implicit(System.String)~System.ReadOnlySpan{System.Char} +System.String.op_Inequality(System.String,System.String) +System.StringComparer +System.StringComparer.#ctor +System.StringComparer.Compare(System.Object,System.Object) +System.StringComparer.Compare(System.String,System.String) +System.StringComparer.Create(System.Globalization.CultureInfo,System.Boolean) +System.StringComparer.Create(System.Globalization.CultureInfo,System.Globalization.CompareOptions) +System.StringComparer.Equals(System.Object,System.Object) +System.StringComparer.Equals(System.String,System.String) +System.StringComparer.FromComparison(System.StringComparison) +System.StringComparer.GetHashCode(System.Object) +System.StringComparer.GetHashCode(System.String) +System.StringComparer.IsWellKnownCultureAwareComparer(System.Collections.Generic.IEqualityComparer{System.String},System.Globalization.CompareInfo@,System.Globalization.CompareOptions@) +System.StringComparer.IsWellKnownOrdinalComparer(System.Collections.Generic.IEqualityComparer{System.String},System.Boolean@) +System.StringComparer.get_CurrentCulture +System.StringComparer.get_CurrentCultureIgnoreCase +System.StringComparer.get_InvariantCulture +System.StringComparer.get_InvariantCultureIgnoreCase +System.StringComparer.get_Ordinal +System.StringComparer.get_OrdinalIgnoreCase +System.StringComparison +System.StringComparison.CurrentCulture +System.StringComparison.CurrentCultureIgnoreCase +System.StringComparison.InvariantCulture +System.StringComparison.InvariantCultureIgnoreCase +System.StringComparison.Ordinal +System.StringComparison.OrdinalIgnoreCase +System.StringNormalizationExtensions +System.StringNormalizationExtensions.IsNormalized(System.String) +System.StringNormalizationExtensions.IsNormalized(System.String,System.Text.NormalizationForm) +System.StringNormalizationExtensions.Normalize(System.String) +System.StringNormalizationExtensions.Normalize(System.String,System.Text.NormalizationForm) +System.StringSplitOptions +System.StringSplitOptions.None +System.StringSplitOptions.RemoveEmptyEntries +System.StringSplitOptions.TrimEntries +System.SystemException +System.SystemException.#ctor +System.SystemException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.SystemException.#ctor(System.String) +System.SystemException.#ctor(System.String,System.Exception) +System.Text.Ascii +System.Text.Ascii.Equals(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.Equals(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char}) +System.Text.Ascii.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char}) +System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.Text.Ascii.FromUtf16(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +System.Text.Ascii.IsValid(System.Byte) +System.Text.Ascii.IsValid(System.Char) +System.Text.Ascii.IsValid(System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.IsValid(System.ReadOnlySpan{System.Char}) +System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) +System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) +System.Text.Ascii.ToLowerInPlace(System.Span{System.Byte},System.Int32@) +System.Text.Ascii.ToLowerInPlace(System.Span{System.Char},System.Int32@) +System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) +System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) +System.Text.Ascii.ToUpperInPlace(System.Span{System.Byte},System.Int32@) +System.Text.Ascii.ToUpperInPlace(System.Span{System.Char},System.Int32@) +System.Text.Ascii.ToUtf16(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Text.Ascii.Trim(System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.Trim(System.ReadOnlySpan{System.Char}) +System.Text.Ascii.TrimEnd(System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.TrimEnd(System.ReadOnlySpan{System.Char}) +System.Text.Ascii.TrimStart(System.ReadOnlySpan{System.Byte}) +System.Text.Ascii.TrimStart(System.ReadOnlySpan{System.Char}) +System.Text.CompositeFormat +System.Text.CompositeFormat.Parse(System.String) +System.Text.CompositeFormat.get_Format +System.Text.CompositeFormat.get_MinimumArgumentCount +System.Text.Decoder +System.Text.Decoder.#ctor +System.Text.Decoder.Convert(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +System.Text.Decoder.Convert(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +System.Text.Decoder.Convert(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +System.Text.Decoder.GetCharCount(System.Byte*,System.Int32,System.Boolean) +System.Text.Decoder.GetCharCount(System.Byte[],System.Int32,System.Int32) +System.Text.Decoder.GetCharCount(System.Byte[],System.Int32,System.Int32,System.Boolean) +System.Text.Decoder.GetCharCount(System.ReadOnlySpan{System.Byte},System.Boolean) +System.Text.Decoder.GetChars(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean) +System.Text.Decoder.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) +System.Text.Decoder.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Boolean) +System.Text.Decoder.GetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Boolean) +System.Text.Decoder.Reset +System.Text.Decoder.get_Fallback +System.Text.Decoder.get_FallbackBuffer +System.Text.Decoder.set_Fallback(System.Text.DecoderFallback) +System.Text.DecoderExceptionFallback +System.Text.DecoderExceptionFallback.#ctor +System.Text.DecoderExceptionFallback.CreateFallbackBuffer +System.Text.DecoderExceptionFallback.Equals(System.Object) +System.Text.DecoderExceptionFallback.GetHashCode +System.Text.DecoderExceptionFallback.get_MaxCharCount +System.Text.DecoderExceptionFallbackBuffer +System.Text.DecoderExceptionFallbackBuffer.#ctor +System.Text.DecoderExceptionFallbackBuffer.Fallback(System.Byte[],System.Int32) +System.Text.DecoderExceptionFallbackBuffer.GetNextChar +System.Text.DecoderExceptionFallbackBuffer.MovePrevious +System.Text.DecoderExceptionFallbackBuffer.get_Remaining +System.Text.DecoderFallback +System.Text.DecoderFallback.#ctor +System.Text.DecoderFallback.CreateFallbackBuffer +System.Text.DecoderFallback.get_ExceptionFallback +System.Text.DecoderFallback.get_MaxCharCount +System.Text.DecoderFallback.get_ReplacementFallback +System.Text.DecoderFallbackBuffer +System.Text.DecoderFallbackBuffer.#ctor +System.Text.DecoderFallbackBuffer.Fallback(System.Byte[],System.Int32) +System.Text.DecoderFallbackBuffer.GetNextChar +System.Text.DecoderFallbackBuffer.MovePrevious +System.Text.DecoderFallbackBuffer.Reset +System.Text.DecoderFallbackBuffer.get_Remaining +System.Text.DecoderFallbackException +System.Text.DecoderFallbackException.#ctor +System.Text.DecoderFallbackException.#ctor(System.String) +System.Text.DecoderFallbackException.#ctor(System.String,System.Byte[],System.Int32) +System.Text.DecoderFallbackException.#ctor(System.String,System.Exception) +System.Text.DecoderFallbackException.get_BytesUnknown +System.Text.DecoderFallbackException.get_Index +System.Text.DecoderReplacementFallback +System.Text.DecoderReplacementFallback.#ctor +System.Text.DecoderReplacementFallback.#ctor(System.String) +System.Text.DecoderReplacementFallback.CreateFallbackBuffer +System.Text.DecoderReplacementFallback.Equals(System.Object) +System.Text.DecoderReplacementFallback.GetHashCode +System.Text.DecoderReplacementFallback.get_DefaultString +System.Text.DecoderReplacementFallback.get_MaxCharCount +System.Text.DecoderReplacementFallbackBuffer +System.Text.DecoderReplacementFallbackBuffer.#ctor(System.Text.DecoderReplacementFallback) +System.Text.DecoderReplacementFallbackBuffer.Fallback(System.Byte[],System.Int32) +System.Text.DecoderReplacementFallbackBuffer.GetNextChar +System.Text.DecoderReplacementFallbackBuffer.MovePrevious +System.Text.DecoderReplacementFallbackBuffer.Reset +System.Text.DecoderReplacementFallbackBuffer.get_Remaining +System.Text.Encoder +System.Text.Encoder.#ctor +System.Text.Encoder.Convert(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +System.Text.Encoder.Convert(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +System.Text.Encoder.Convert(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +System.Text.Encoder.GetByteCount(System.Char*,System.Int32,System.Boolean) +System.Text.Encoder.GetByteCount(System.Char[],System.Int32,System.Int32,System.Boolean) +System.Text.Encoder.GetByteCount(System.ReadOnlySpan{System.Char},System.Boolean) +System.Text.Encoder.GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean) +System.Text.Encoder.GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Boolean) +System.Text.Encoder.GetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Boolean) +System.Text.Encoder.Reset +System.Text.Encoder.get_Fallback +System.Text.Encoder.get_FallbackBuffer +System.Text.Encoder.set_Fallback(System.Text.EncoderFallback) +System.Text.EncoderExceptionFallback +System.Text.EncoderExceptionFallback.#ctor +System.Text.EncoderExceptionFallback.CreateFallbackBuffer +System.Text.EncoderExceptionFallback.Equals(System.Object) +System.Text.EncoderExceptionFallback.GetHashCode +System.Text.EncoderExceptionFallback.get_MaxCharCount +System.Text.EncoderExceptionFallbackBuffer +System.Text.EncoderExceptionFallbackBuffer.#ctor +System.Text.EncoderExceptionFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) +System.Text.EncoderExceptionFallbackBuffer.Fallback(System.Char,System.Int32) +System.Text.EncoderExceptionFallbackBuffer.GetNextChar +System.Text.EncoderExceptionFallbackBuffer.MovePrevious +System.Text.EncoderExceptionFallbackBuffer.get_Remaining +System.Text.EncoderFallback +System.Text.EncoderFallback.#ctor +System.Text.EncoderFallback.CreateFallbackBuffer +System.Text.EncoderFallback.get_ExceptionFallback +System.Text.EncoderFallback.get_MaxCharCount +System.Text.EncoderFallback.get_ReplacementFallback +System.Text.EncoderFallbackBuffer +System.Text.EncoderFallbackBuffer.#ctor +System.Text.EncoderFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) +System.Text.EncoderFallbackBuffer.Fallback(System.Char,System.Int32) +System.Text.EncoderFallbackBuffer.GetNextChar +System.Text.EncoderFallbackBuffer.MovePrevious +System.Text.EncoderFallbackBuffer.Reset +System.Text.EncoderFallbackBuffer.get_Remaining +System.Text.EncoderFallbackException +System.Text.EncoderFallbackException.#ctor +System.Text.EncoderFallbackException.#ctor(System.String) +System.Text.EncoderFallbackException.#ctor(System.String,System.Exception) +System.Text.EncoderFallbackException.IsUnknownSurrogate +System.Text.EncoderFallbackException.get_CharUnknown +System.Text.EncoderFallbackException.get_CharUnknownHigh +System.Text.EncoderFallbackException.get_CharUnknownLow +System.Text.EncoderFallbackException.get_Index +System.Text.EncoderReplacementFallback +System.Text.EncoderReplacementFallback.#ctor +System.Text.EncoderReplacementFallback.#ctor(System.String) +System.Text.EncoderReplacementFallback.CreateFallbackBuffer +System.Text.EncoderReplacementFallback.Equals(System.Object) +System.Text.EncoderReplacementFallback.GetHashCode +System.Text.EncoderReplacementFallback.get_DefaultString +System.Text.EncoderReplacementFallback.get_MaxCharCount +System.Text.EncoderReplacementFallbackBuffer +System.Text.EncoderReplacementFallbackBuffer.#ctor(System.Text.EncoderReplacementFallback) +System.Text.EncoderReplacementFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) +System.Text.EncoderReplacementFallbackBuffer.Fallback(System.Char,System.Int32) +System.Text.EncoderReplacementFallbackBuffer.GetNextChar +System.Text.EncoderReplacementFallbackBuffer.MovePrevious +System.Text.EncoderReplacementFallbackBuffer.Reset +System.Text.EncoderReplacementFallbackBuffer.get_Remaining +System.Text.Encoding +System.Text.Encoding.#ctor +System.Text.Encoding.#ctor(System.Int32) +System.Text.Encoding.#ctor(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) +System.Text.Encoding.Clone +System.Text.Encoding.Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[]) +System.Text.Encoding.Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[],System.Int32,System.Int32) +System.Text.Encoding.CreateTranscodingStream(System.IO.Stream,System.Text.Encoding,System.Text.Encoding,System.Boolean) +System.Text.Encoding.Equals(System.Object) +System.Text.Encoding.GetByteCount(System.Char*,System.Int32) +System.Text.Encoding.GetByteCount(System.Char[]) +System.Text.Encoding.GetByteCount(System.Char[],System.Int32,System.Int32) +System.Text.Encoding.GetByteCount(System.ReadOnlySpan{System.Char}) +System.Text.Encoding.GetByteCount(System.String) +System.Text.Encoding.GetByteCount(System.String,System.Int32,System.Int32) +System.Text.Encoding.GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32) +System.Text.Encoding.GetBytes(System.Char[]) +System.Text.Encoding.GetBytes(System.Char[],System.Int32,System.Int32) +System.Text.Encoding.GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32) +System.Text.Encoding.GetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte}) +System.Text.Encoding.GetBytes(System.String) +System.Text.Encoding.GetBytes(System.String,System.Int32,System.Int32) +System.Text.Encoding.GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32) +System.Text.Encoding.GetCharCount(System.Byte*,System.Int32) +System.Text.Encoding.GetCharCount(System.Byte[]) +System.Text.Encoding.GetCharCount(System.Byte[],System.Int32,System.Int32) +System.Text.Encoding.GetCharCount(System.ReadOnlySpan{System.Byte}) +System.Text.Encoding.GetChars(System.Byte*,System.Int32,System.Char*,System.Int32) +System.Text.Encoding.GetChars(System.Byte[]) +System.Text.Encoding.GetChars(System.Byte[],System.Int32,System.Int32) +System.Text.Encoding.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) +System.Text.Encoding.GetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char}) +System.Text.Encoding.GetDecoder +System.Text.Encoding.GetEncoder +System.Text.Encoding.GetEncoding(System.Int32) +System.Text.Encoding.GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) +System.Text.Encoding.GetEncoding(System.String) +System.Text.Encoding.GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback) +System.Text.Encoding.GetEncodings +System.Text.Encoding.GetHashCode +System.Text.Encoding.GetMaxByteCount(System.Int32) +System.Text.Encoding.GetMaxCharCount(System.Int32) +System.Text.Encoding.GetPreamble +System.Text.Encoding.GetString(System.Byte*,System.Int32) +System.Text.Encoding.GetString(System.Byte[]) +System.Text.Encoding.GetString(System.Byte[],System.Int32,System.Int32) +System.Text.Encoding.GetString(System.ReadOnlySpan{System.Byte}) +System.Text.Encoding.IsAlwaysNormalized +System.Text.Encoding.IsAlwaysNormalized(System.Text.NormalizationForm) +System.Text.Encoding.RegisterProvider(System.Text.EncodingProvider) +System.Text.Encoding.TryGetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +System.Text.Encoding.TryGetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +System.Text.Encoding.get_ASCII +System.Text.Encoding.get_BigEndianUnicode +System.Text.Encoding.get_BodyName +System.Text.Encoding.get_CodePage +System.Text.Encoding.get_DecoderFallback +System.Text.Encoding.get_Default +System.Text.Encoding.get_EncoderFallback +System.Text.Encoding.get_EncodingName +System.Text.Encoding.get_HeaderName +System.Text.Encoding.get_IsBrowserDisplay +System.Text.Encoding.get_IsBrowserSave +System.Text.Encoding.get_IsMailNewsDisplay +System.Text.Encoding.get_IsMailNewsSave +System.Text.Encoding.get_IsReadOnly +System.Text.Encoding.get_IsSingleByte +System.Text.Encoding.get_Latin1 +System.Text.Encoding.get_Preamble +System.Text.Encoding.get_UTF32 +System.Text.Encoding.get_UTF7 +System.Text.Encoding.get_UTF8 +System.Text.Encoding.get_Unicode +System.Text.Encoding.get_WebName +System.Text.Encoding.get_WindowsCodePage +System.Text.Encoding.set_DecoderFallback(System.Text.DecoderFallback) +System.Text.Encoding.set_EncoderFallback(System.Text.EncoderFallback) +System.Text.EncodingInfo +System.Text.EncodingInfo.#ctor(System.Text.EncodingProvider,System.Int32,System.String,System.String) +System.Text.EncodingInfo.Equals(System.Object) +System.Text.EncodingInfo.GetEncoding +System.Text.EncodingInfo.GetHashCode +System.Text.EncodingInfo.get_CodePage +System.Text.EncodingInfo.get_DisplayName +System.Text.EncodingInfo.get_Name +System.Text.EncodingProvider +System.Text.EncodingProvider.#ctor +System.Text.EncodingProvider.GetEncoding(System.Int32) +System.Text.EncodingProvider.GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) +System.Text.EncodingProvider.GetEncoding(System.String) +System.Text.EncodingProvider.GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback) +System.Text.EncodingProvider.GetEncodings +System.Text.NormalizationForm +System.Text.NormalizationForm.FormC +System.Text.NormalizationForm.FormD +System.Text.NormalizationForm.FormKC +System.Text.NormalizationForm.FormKD +System.Text.Rune +System.Text.Rune.#ctor(System.Char) +System.Text.Rune.#ctor(System.Char,System.Char) +System.Text.Rune.#ctor(System.Int32) +System.Text.Rune.#ctor(System.UInt32) +System.Text.Rune.CompareTo(System.Text.Rune) +System.Text.Rune.DecodeFromUtf16(System.ReadOnlySpan{System.Char},System.Text.Rune@,System.Int32@) +System.Text.Rune.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Text.Rune@,System.Int32@) +System.Text.Rune.DecodeLastFromUtf16(System.ReadOnlySpan{System.Char},System.Text.Rune@,System.Int32@) +System.Text.Rune.DecodeLastFromUtf8(System.ReadOnlySpan{System.Byte},System.Text.Rune@,System.Int32@) +System.Text.Rune.EncodeToUtf16(System.Span{System.Char}) +System.Text.Rune.EncodeToUtf8(System.Span{System.Byte}) +System.Text.Rune.Equals(System.Object) +System.Text.Rune.Equals(System.Text.Rune) +System.Text.Rune.GetHashCode +System.Text.Rune.GetNumericValue(System.Text.Rune) +System.Text.Rune.GetRuneAt(System.String,System.Int32) +System.Text.Rune.GetUnicodeCategory(System.Text.Rune) +System.Text.Rune.IsControl(System.Text.Rune) +System.Text.Rune.IsDigit(System.Text.Rune) +System.Text.Rune.IsLetter(System.Text.Rune) +System.Text.Rune.IsLetterOrDigit(System.Text.Rune) +System.Text.Rune.IsLower(System.Text.Rune) +System.Text.Rune.IsNumber(System.Text.Rune) +System.Text.Rune.IsPunctuation(System.Text.Rune) +System.Text.Rune.IsSeparator(System.Text.Rune) +System.Text.Rune.IsSymbol(System.Text.Rune) +System.Text.Rune.IsUpper(System.Text.Rune) +System.Text.Rune.IsValid(System.Int32) +System.Text.Rune.IsValid(System.UInt32) +System.Text.Rune.IsWhiteSpace(System.Text.Rune) +System.Text.Rune.ToLower(System.Text.Rune,System.Globalization.CultureInfo) +System.Text.Rune.ToLowerInvariant(System.Text.Rune) +System.Text.Rune.ToString +System.Text.Rune.ToUpper(System.Text.Rune,System.Globalization.CultureInfo) +System.Text.Rune.ToUpperInvariant(System.Text.Rune) +System.Text.Rune.TryCreate(System.Char,System.Char,System.Text.Rune@) +System.Text.Rune.TryCreate(System.Char,System.Text.Rune@) +System.Text.Rune.TryCreate(System.Int32,System.Text.Rune@) +System.Text.Rune.TryCreate(System.UInt32,System.Text.Rune@) +System.Text.Rune.TryEncodeToUtf16(System.Span{System.Char},System.Int32@) +System.Text.Rune.TryEncodeToUtf8(System.Span{System.Byte},System.Int32@) +System.Text.Rune.TryGetRuneAt(System.String,System.Int32,System.Text.Rune@) +System.Text.Rune.get_IsAscii +System.Text.Rune.get_IsBmp +System.Text.Rune.get_Plane +System.Text.Rune.get_ReplacementChar +System.Text.Rune.get_Utf16SequenceLength +System.Text.Rune.get_Utf8SequenceLength +System.Text.Rune.get_Value +System.Text.Rune.op_Equality(System.Text.Rune,System.Text.Rune) +System.Text.Rune.op_Explicit(System.Char)~System.Text.Rune +System.Text.Rune.op_Explicit(System.Int32)~System.Text.Rune +System.Text.Rune.op_Explicit(System.UInt32)~System.Text.Rune +System.Text.Rune.op_GreaterThan(System.Text.Rune,System.Text.Rune) +System.Text.Rune.op_GreaterThanOrEqual(System.Text.Rune,System.Text.Rune) +System.Text.Rune.op_Inequality(System.Text.Rune,System.Text.Rune) +System.Text.Rune.op_LessThan(System.Text.Rune,System.Text.Rune) +System.Text.Rune.op_LessThanOrEqual(System.Text.Rune,System.Text.Rune) +System.Text.StringBuilder +System.Text.StringBuilder.#ctor +System.Text.StringBuilder.#ctor(System.Int32) +System.Text.StringBuilder.#ctor(System.Int32,System.Int32) +System.Text.StringBuilder.#ctor(System.String) +System.Text.StringBuilder.#ctor(System.String,System.Int32) +System.Text.StringBuilder.#ctor(System.String,System.Int32,System.Int32,System.Int32) +System.Text.StringBuilder.Append(System.Boolean) +System.Text.StringBuilder.Append(System.Byte) +System.Text.StringBuilder.Append(System.Char) +System.Text.StringBuilder.Append(System.Char*,System.Int32) +System.Text.StringBuilder.Append(System.Char,System.Int32) +System.Text.StringBuilder.Append(System.Char[]) +System.Text.StringBuilder.Append(System.Char[],System.Int32,System.Int32) +System.Text.StringBuilder.Append(System.Decimal) +System.Text.StringBuilder.Append(System.Double) +System.Text.StringBuilder.Append(System.IFormatProvider,System.Text.StringBuilder.AppendInterpolatedStringHandler@) +System.Text.StringBuilder.Append(System.Int16) +System.Text.StringBuilder.Append(System.Int32) +System.Text.StringBuilder.Append(System.Int64) +System.Text.StringBuilder.Append(System.Object) +System.Text.StringBuilder.Append(System.ReadOnlyMemory{System.Char}) +System.Text.StringBuilder.Append(System.ReadOnlySpan{System.Char}) +System.Text.StringBuilder.Append(System.SByte) +System.Text.StringBuilder.Append(System.Single) +System.Text.StringBuilder.Append(System.String) +System.Text.StringBuilder.Append(System.String,System.Int32,System.Int32) +System.Text.StringBuilder.Append(System.Text.StringBuilder) +System.Text.StringBuilder.Append(System.Text.StringBuilder,System.Int32,System.Int32) +System.Text.StringBuilder.Append(System.Text.StringBuilder.AppendInterpolatedStringHandler@) +System.Text.StringBuilder.Append(System.UInt16) +System.Text.StringBuilder.Append(System.UInt32) +System.Text.StringBuilder.Append(System.UInt64) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object[]) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.ReadOnlySpan{System.Object}) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) +System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) +System.Text.StringBuilder.AppendFormat(System.String,System.Object) +System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object) +System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object,System.Object) +System.Text.StringBuilder.AppendFormat(System.String,System.Object[]) +System.Text.StringBuilder.AppendFormat(System.String,System.ReadOnlySpan{System.Object}) +System.Text.StringBuilder.AppendFormat``1(System.IFormatProvider,System.Text.CompositeFormat,``0) +System.Text.StringBuilder.AppendFormat``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) +System.Text.StringBuilder.AppendFormat``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) +System.Text.StringBuilder.AppendInterpolatedStringHandler +System.Text.StringBuilder.AppendInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Text.StringBuilder) +System.Text.StringBuilder.AppendInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Text.StringBuilder,System.IFormatProvider) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.String) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendLiteral(System.String) +System.Text.StringBuilder.AppendJoin(System.Char,System.Object[]) +System.Text.StringBuilder.AppendJoin(System.Char,System.ReadOnlySpan{System.Object}) +System.Text.StringBuilder.AppendJoin(System.Char,System.ReadOnlySpan{System.String}) +System.Text.StringBuilder.AppendJoin(System.Char,System.String[]) +System.Text.StringBuilder.AppendJoin(System.String,System.Object[]) +System.Text.StringBuilder.AppendJoin(System.String,System.ReadOnlySpan{System.Object}) +System.Text.StringBuilder.AppendJoin(System.String,System.ReadOnlySpan{System.String}) +System.Text.StringBuilder.AppendJoin(System.String,System.String[]) +System.Text.StringBuilder.AppendJoin``1(System.Char,System.Collections.Generic.IEnumerable{``0}) +System.Text.StringBuilder.AppendJoin``1(System.String,System.Collections.Generic.IEnumerable{``0}) +System.Text.StringBuilder.AppendLine +System.Text.StringBuilder.AppendLine(System.IFormatProvider,System.Text.StringBuilder.AppendInterpolatedStringHandler@) +System.Text.StringBuilder.AppendLine(System.String) +System.Text.StringBuilder.AppendLine(System.Text.StringBuilder.AppendInterpolatedStringHandler@) +System.Text.StringBuilder.ChunkEnumerator +System.Text.StringBuilder.ChunkEnumerator.GetEnumerator +System.Text.StringBuilder.ChunkEnumerator.MoveNext +System.Text.StringBuilder.ChunkEnumerator.get_Current +System.Text.StringBuilder.Clear +System.Text.StringBuilder.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) +System.Text.StringBuilder.CopyTo(System.Int32,System.Span{System.Char},System.Int32) +System.Text.StringBuilder.EnsureCapacity(System.Int32) +System.Text.StringBuilder.Equals(System.ReadOnlySpan{System.Char}) +System.Text.StringBuilder.Equals(System.Text.StringBuilder) +System.Text.StringBuilder.GetChunks +System.Text.StringBuilder.Insert(System.Int32,System.Boolean) +System.Text.StringBuilder.Insert(System.Int32,System.Byte) +System.Text.StringBuilder.Insert(System.Int32,System.Char) +System.Text.StringBuilder.Insert(System.Int32,System.Char[]) +System.Text.StringBuilder.Insert(System.Int32,System.Char[],System.Int32,System.Int32) +System.Text.StringBuilder.Insert(System.Int32,System.Decimal) +System.Text.StringBuilder.Insert(System.Int32,System.Double) +System.Text.StringBuilder.Insert(System.Int32,System.Int16) +System.Text.StringBuilder.Insert(System.Int32,System.Int32) +System.Text.StringBuilder.Insert(System.Int32,System.Int64) +System.Text.StringBuilder.Insert(System.Int32,System.Object) +System.Text.StringBuilder.Insert(System.Int32,System.ReadOnlySpan{System.Char}) +System.Text.StringBuilder.Insert(System.Int32,System.SByte) +System.Text.StringBuilder.Insert(System.Int32,System.Single) +System.Text.StringBuilder.Insert(System.Int32,System.String) +System.Text.StringBuilder.Insert(System.Int32,System.String,System.Int32) +System.Text.StringBuilder.Insert(System.Int32,System.UInt16) +System.Text.StringBuilder.Insert(System.Int32,System.UInt32) +System.Text.StringBuilder.Insert(System.Int32,System.UInt64) +System.Text.StringBuilder.Remove(System.Int32,System.Int32) +System.Text.StringBuilder.Replace(System.Char,System.Char) +System.Text.StringBuilder.Replace(System.Char,System.Char,System.Int32,System.Int32) +System.Text.StringBuilder.Replace(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +System.Text.StringBuilder.Replace(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Int32,System.Int32) +System.Text.StringBuilder.Replace(System.String,System.String) +System.Text.StringBuilder.Replace(System.String,System.String,System.Int32,System.Int32) +System.Text.StringBuilder.ToString +System.Text.StringBuilder.ToString(System.Int32,System.Int32) +System.Text.StringBuilder.get_Capacity +System.Text.StringBuilder.get_Chars(System.Int32) +System.Text.StringBuilder.get_Length +System.Text.StringBuilder.get_MaxCapacity +System.Text.StringBuilder.set_Capacity(System.Int32) +System.Text.StringBuilder.set_Chars(System.Int32,System.Char) +System.Text.StringBuilder.set_Length(System.Int32) +System.Text.StringRuneEnumerator +System.Text.StringRuneEnumerator.GetEnumerator +System.Text.StringRuneEnumerator.MoveNext +System.Text.StringRuneEnumerator.get_Current +System.Text.Unicode.Utf8 +System.Text.Unicode.Utf8.FromUtf16(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean,System.Boolean) +System.Text.Unicode.Utf8.IsValid(System.ReadOnlySpan{System.Byte}) +System.Text.Unicode.Utf8.ToUtf16(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Int32@,System.Boolean,System.Boolean) +System.Text.Unicode.Utf8.TryWrite(System.Span{System.Byte},System.IFormatProvider,System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler@,System.Int32@) +System.Text.Unicode.Utf8.TryWrite(System.Span{System.Byte},System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler@,System.Int32@) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Span{System.Byte},System.Boolean@) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Span{System.Byte},System.IFormatProvider,System.Boolean@) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Byte}) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Byte},System.Int32,System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendLiteral(System.String) +System.Threading.CancellationToken +System.Threading.CancellationToken.#ctor(System.Boolean) +System.Threading.CancellationToken.Equals(System.Object) +System.Threading.CancellationToken.Equals(System.Threading.CancellationToken) +System.Threading.CancellationToken.GetHashCode +System.Threading.CancellationToken.Register(System.Action) +System.Threading.CancellationToken.Register(System.Action,System.Boolean) +System.Threading.CancellationToken.Register(System.Action{System.Object,System.Threading.CancellationToken},System.Object) +System.Threading.CancellationToken.Register(System.Action{System.Object},System.Object) +System.Threading.CancellationToken.Register(System.Action{System.Object},System.Object,System.Boolean) +System.Threading.CancellationToken.ThrowIfCancellationRequested +System.Threading.CancellationToken.UnsafeRegister(System.Action{System.Object,System.Threading.CancellationToken},System.Object) +System.Threading.CancellationToken.UnsafeRegister(System.Action{System.Object},System.Object) +System.Threading.CancellationToken.get_CanBeCanceled +System.Threading.CancellationToken.get_IsCancellationRequested +System.Threading.CancellationToken.get_None +System.Threading.CancellationToken.get_WaitHandle +System.Threading.CancellationToken.op_Equality(System.Threading.CancellationToken,System.Threading.CancellationToken) +System.Threading.CancellationToken.op_Inequality(System.Threading.CancellationToken,System.Threading.CancellationToken) +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler) +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32) +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32) +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Complete +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_Completion +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_ConcurrentScheduler +System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_ExclusiveScheduler +System.Threading.Tasks.ConfigureAwaitOptions +System.Threading.Tasks.ConfigureAwaitOptions.ContinueOnCapturedContext +System.Threading.Tasks.ConfigureAwaitOptions.ForceYielding +System.Threading.Tasks.ConfigureAwaitOptions.None +System.Threading.Tasks.ConfigureAwaitOptions.SuppressThrowing +System.Threading.Tasks.Sources.IValueTaskSource +System.Threading.Tasks.Sources.IValueTaskSource.GetResult(System.Int16) +System.Threading.Tasks.Sources.IValueTaskSource.GetStatus(System.Int16) +System.Threading.Tasks.Sources.IValueTaskSource.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) +System.Threading.Tasks.Sources.IValueTaskSource`1 +System.Threading.Tasks.Sources.IValueTaskSource`1.GetResult(System.Int16) +System.Threading.Tasks.Sources.IValueTaskSource`1.GetStatus(System.Int16) +System.Threading.Tasks.Sources.IValueTaskSource`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1 +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetResult(System.Int16) +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetStatus(System.Int16) +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.Reset +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetException(System.Exception) +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetResult(`0) +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.get_RunContinuationsAsynchronously +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.get_Version +System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.set_RunContinuationsAsynchronously(System.Boolean) +System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags +System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.FlowExecutionContext +System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.None +System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.UseSchedulingContext +System.Threading.Tasks.Sources.ValueTaskSourceStatus +System.Threading.Tasks.Sources.ValueTaskSourceStatus.Canceled +System.Threading.Tasks.Sources.ValueTaskSourceStatus.Faulted +System.Threading.Tasks.Sources.ValueTaskSourceStatus.Pending +System.Threading.Tasks.Sources.ValueTaskSourceStatus.Succeeded +System.Threading.Tasks.Task +System.Threading.Tasks.Task.ConfigureAwait(System.Boolean) +System.Threading.Tasks.Task.ConfigureAwait(System.Threading.Tasks.ConfigureAwaitOptions) +System.Threading.Tasks.Task.Dispose +System.Threading.Tasks.Task.Dispose(System.Boolean) +System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken) +System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken) +System.Threading.Tasks.Task.FromException(System.Exception) +System.Threading.Tasks.Task.FromException``1(System.Exception) +System.Threading.Tasks.Task.FromResult``1(``0) +System.Threading.Tasks.Task.GetAwaiter +System.Threading.Tasks.Task.get_AsyncState +System.Threading.Tasks.Task.get_CompletedTask +System.Threading.Tasks.Task.get_CreationOptions +System.Threading.Tasks.Task.get_CurrentId +System.Threading.Tasks.Task.get_Exception +System.Threading.Tasks.Task.get_Factory +System.Threading.Tasks.Task.get_Id +System.Threading.Tasks.Task.get_IsCanceled +System.Threading.Tasks.Task.get_IsCompleted +System.Threading.Tasks.Task.get_IsCompletedSuccessfully +System.Threading.Tasks.Task.get_IsFaulted +System.Threading.Tasks.Task.get_Status +System.Threading.Tasks.TaskAsyncEnumerableExtensions +System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait(System.IAsyncDisposable,System.Boolean) +System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Boolean) +System.Threading.Tasks.TaskAsyncEnumerableExtensions.ToBlockingEnumerable``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken) +System.Threading.Tasks.TaskAsyncEnumerableExtensions.WithCancellation``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken) +System.Threading.Tasks.TaskCanceledException +System.Threading.Tasks.TaskCanceledException.#ctor +System.Threading.Tasks.TaskCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Threading.Tasks.TaskCanceledException.#ctor(System.String) +System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception) +System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception,System.Threading.CancellationToken) +System.Threading.Tasks.TaskCanceledException.#ctor(System.Threading.Tasks.Task) +System.Threading.Tasks.TaskCanceledException.get_Task +System.Threading.Tasks.TaskCompletionSource +System.Threading.Tasks.TaskCompletionSource.#ctor +System.Threading.Tasks.TaskCompletionSource.#ctor(System.Object) +System.Threading.Tasks.TaskCompletionSource.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions) +System.Threading.Tasks.TaskCompletionSource.#ctor(System.Threading.Tasks.TaskCreationOptions) +System.Threading.Tasks.TaskCompletionSource.SetCanceled +System.Threading.Tasks.TaskCompletionSource.SetCanceled(System.Threading.CancellationToken) +System.Threading.Tasks.TaskCompletionSource.SetException(System.Collections.Generic.IEnumerable{System.Exception}) +System.Threading.Tasks.TaskCompletionSource.SetException(System.Exception) +System.Threading.Tasks.TaskCompletionSource.SetFromTask(System.Threading.Tasks.Task) +System.Threading.Tasks.TaskCompletionSource.SetResult +System.Threading.Tasks.TaskCompletionSource.TrySetCanceled +System.Threading.Tasks.TaskCompletionSource.TrySetCanceled(System.Threading.CancellationToken) +System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) +System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Exception) +System.Threading.Tasks.TaskCompletionSource.TrySetFromTask(System.Threading.Tasks.Task) +System.Threading.Tasks.TaskCompletionSource.TrySetResult +System.Threading.Tasks.TaskCompletionSource.get_Task +System.Threading.Tasks.TaskCompletionSource`1 +System.Threading.Tasks.TaskCompletionSource`1.#ctor +System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object) +System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions) +System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Threading.Tasks.TaskCreationOptions) +System.Threading.Tasks.TaskCompletionSource`1.SetCanceled +System.Threading.Tasks.TaskCompletionSource`1.SetCanceled(System.Threading.CancellationToken) +System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception}) +System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception) +System.Threading.Tasks.TaskCompletionSource`1.SetFromTask(System.Threading.Tasks.Task{`0}) +System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0) +System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled +System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken) +System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) +System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception) +System.Threading.Tasks.TaskCompletionSource`1.TrySetFromTask(System.Threading.Tasks.Task{`0}) +System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0) +System.Threading.Tasks.TaskCompletionSource`1.get_Task +System.Threading.Tasks.TaskContinuationOptions +System.Threading.Tasks.TaskContinuationOptions.AttachedToParent +System.Threading.Tasks.TaskContinuationOptions.DenyChildAttach +System.Threading.Tasks.TaskContinuationOptions.ExecuteSynchronously +System.Threading.Tasks.TaskContinuationOptions.HideScheduler +System.Threading.Tasks.TaskContinuationOptions.LazyCancellation +System.Threading.Tasks.TaskContinuationOptions.LongRunning +System.Threading.Tasks.TaskContinuationOptions.None +System.Threading.Tasks.TaskContinuationOptions.NotOnCanceled +System.Threading.Tasks.TaskContinuationOptions.NotOnFaulted +System.Threading.Tasks.TaskContinuationOptions.NotOnRanToCompletion +System.Threading.Tasks.TaskContinuationOptions.OnlyOnCanceled +System.Threading.Tasks.TaskContinuationOptions.OnlyOnFaulted +System.Threading.Tasks.TaskContinuationOptions.OnlyOnRanToCompletion +System.Threading.Tasks.TaskContinuationOptions.PreferFairness +System.Threading.Tasks.TaskContinuationOptions.RunContinuationsAsynchronously +System.Threading.Tasks.TaskCreationOptions +System.Threading.Tasks.TaskCreationOptions.AttachedToParent +System.Threading.Tasks.TaskCreationOptions.DenyChildAttach +System.Threading.Tasks.TaskCreationOptions.HideScheduler +System.Threading.Tasks.TaskCreationOptions.LongRunning +System.Threading.Tasks.TaskCreationOptions.None +System.Threading.Tasks.TaskCreationOptions.PreferFairness +System.Threading.Tasks.TaskCreationOptions.RunContinuationsAsynchronously +System.Threading.Tasks.TaskExtensions +System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task}) +System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}}) +System.Threading.Tasks.TaskSchedulerException +System.Threading.Tasks.TaskSchedulerException.#ctor +System.Threading.Tasks.TaskSchedulerException.#ctor(System.Exception) +System.Threading.Tasks.TaskSchedulerException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Threading.Tasks.TaskSchedulerException.#ctor(System.String) +System.Threading.Tasks.TaskSchedulerException.#ctor(System.String,System.Exception) +System.Threading.Tasks.TaskStatus +System.Threading.Tasks.TaskStatus.Canceled +System.Threading.Tasks.TaskStatus.Created +System.Threading.Tasks.TaskStatus.Faulted +System.Threading.Tasks.TaskStatus.RanToCompletion +System.Threading.Tasks.TaskStatus.Running +System.Threading.Tasks.TaskStatus.WaitingForActivation +System.Threading.Tasks.TaskStatus.WaitingForChildrenToComplete +System.Threading.Tasks.TaskStatus.WaitingToRun +System.Threading.Tasks.TaskToAsyncResult +System.Threading.Tasks.TaskToAsyncResult.Begin(System.Threading.Tasks.Task,System.AsyncCallback,System.Object) +System.Threading.Tasks.TaskToAsyncResult.End(System.IAsyncResult) +System.Threading.Tasks.TaskToAsyncResult.End``1(System.IAsyncResult) +System.Threading.Tasks.TaskToAsyncResult.Unwrap(System.IAsyncResult) +System.Threading.Tasks.TaskToAsyncResult.Unwrap``1(System.IAsyncResult) +System.Threading.Tasks.Task`1 +System.Threading.Tasks.Task`1.ConfigureAwait(System.Boolean) +System.Threading.Tasks.Task`1.ConfigureAwait(System.Threading.Tasks.ConfigureAwaitOptions) +System.Threading.Tasks.Task`1.GetAwaiter +System.Threading.Tasks.Task`1.get_Factory +System.Threading.Tasks.Task`1.get_Result +System.Threading.Tasks.UnobservedTaskExceptionEventArgs +System.Threading.Tasks.UnobservedTaskExceptionEventArgs.#ctor(System.AggregateException) +System.Threading.Tasks.UnobservedTaskExceptionEventArgs.SetObserved +System.Threading.Tasks.UnobservedTaskExceptionEventArgs.get_Exception +System.Threading.Tasks.UnobservedTaskExceptionEventArgs.get_Observed +System.Threading.Tasks.ValueTask +System.Threading.Tasks.ValueTask.#ctor(System.Threading.Tasks.Sources.IValueTaskSource,System.Int16) +System.Threading.Tasks.ValueTask.#ctor(System.Threading.Tasks.Task) +System.Threading.Tasks.ValueTask.AsTask +System.Threading.Tasks.ValueTask.ConfigureAwait(System.Boolean) +System.Threading.Tasks.ValueTask.Equals(System.Object) +System.Threading.Tasks.ValueTask.Equals(System.Threading.Tasks.ValueTask) +System.Threading.Tasks.ValueTask.FromCanceled(System.Threading.CancellationToken) +System.Threading.Tasks.ValueTask.FromCanceled``1(System.Threading.CancellationToken) +System.Threading.Tasks.ValueTask.FromException(System.Exception) +System.Threading.Tasks.ValueTask.FromException``1(System.Exception) +System.Threading.Tasks.ValueTask.FromResult``1(``0) +System.Threading.Tasks.ValueTask.GetAwaiter +System.Threading.Tasks.ValueTask.GetHashCode +System.Threading.Tasks.ValueTask.Preserve +System.Threading.Tasks.ValueTask.get_CompletedTask +System.Threading.Tasks.ValueTask.get_IsCanceled +System.Threading.Tasks.ValueTask.get_IsCompleted +System.Threading.Tasks.ValueTask.get_IsCompletedSuccessfully +System.Threading.Tasks.ValueTask.get_IsFaulted +System.Threading.Tasks.ValueTask.op_Equality(System.Threading.Tasks.ValueTask,System.Threading.Tasks.ValueTask) +System.Threading.Tasks.ValueTask.op_Inequality(System.Threading.Tasks.ValueTask,System.Threading.Tasks.ValueTask) +System.Threading.Tasks.ValueTask`1 +System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Sources.IValueTaskSource{`0},System.Int16) +System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Task{`0}) +System.Threading.Tasks.ValueTask`1.#ctor(`0) +System.Threading.Tasks.ValueTask`1.AsTask +System.Threading.Tasks.ValueTask`1.ConfigureAwait(System.Boolean) +System.Threading.Tasks.ValueTask`1.Equals(System.Object) +System.Threading.Tasks.ValueTask`1.Equals(System.Threading.Tasks.ValueTask{`0}) +System.Threading.Tasks.ValueTask`1.GetAwaiter +System.Threading.Tasks.ValueTask`1.GetHashCode +System.Threading.Tasks.ValueTask`1.Preserve +System.Threading.Tasks.ValueTask`1.ToString +System.Threading.Tasks.ValueTask`1.get_IsCanceled +System.Threading.Tasks.ValueTask`1.get_IsCompleted +System.Threading.Tasks.ValueTask`1.get_IsCompletedSuccessfully +System.Threading.Tasks.ValueTask`1.get_IsFaulted +System.Threading.Tasks.ValueTask`1.get_Result +System.Threading.Tasks.ValueTask`1.op_Equality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0}) +System.Threading.Tasks.ValueTask`1.op_Inequality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0}) +System.TimeOnly +System.TimeOnly.#ctor(System.Int32,System.Int32) +System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32) +System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) +System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.TimeOnly.#ctor(System.Int64) +System.TimeOnly.Add(System.TimeSpan) +System.TimeOnly.Add(System.TimeSpan,System.Int32@) +System.TimeOnly.AddHours(System.Double) +System.TimeOnly.AddHours(System.Double,System.Int32@) +System.TimeOnly.AddMinutes(System.Double) +System.TimeOnly.AddMinutes(System.Double,System.Int32@) +System.TimeOnly.CompareTo(System.Object) +System.TimeOnly.CompareTo(System.TimeOnly) +System.TimeOnly.Deconstruct(System.Int32@,System.Int32@) +System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@) +System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@,System.Int32@) +System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@,System.Int32@,System.Int32@) +System.TimeOnly.Equals(System.Object) +System.TimeOnly.Equals(System.TimeOnly) +System.TimeOnly.FromDateTime(System.DateTime) +System.TimeOnly.FromTimeSpan(System.TimeSpan) +System.TimeOnly.GetHashCode +System.TimeOnly.IsBetween(System.TimeOnly,System.TimeOnly) +System.TimeOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.TimeOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.TimeOnly.Parse(System.String) +System.TimeOnly.Parse(System.String,System.IFormatProvider) +System.TimeOnly.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[]) +System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.TimeOnly.ParseExact(System.String,System.String) +System.TimeOnly.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +System.TimeOnly.ParseExact(System.String,System.String[]) +System.TimeOnly.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +System.TimeOnly.ToLongTimeString +System.TimeOnly.ToShortTimeString +System.TimeOnly.ToString +System.TimeOnly.ToString(System.IFormatProvider) +System.TimeOnly.ToString(System.String) +System.TimeOnly.ToString(System.String,System.IFormatProvider) +System.TimeOnly.ToTimeSpan +System.TimeOnly.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.TimeOnly.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeOnly@) +System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.TimeOnly@) +System.TimeOnly.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +System.TimeOnly.TryParse(System.String,System.IFormatProvider,System.TimeOnly@) +System.TimeOnly.TryParse(System.String,System.TimeOnly@) +System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.TimeOnly@) +System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.TimeOnly@) +System.TimeOnly.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +System.TimeOnly.TryParseExact(System.String,System.String,System.TimeOnly@) +System.TimeOnly.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +System.TimeOnly.TryParseExact(System.String,System.String[],System.TimeOnly@) +System.TimeOnly.get_Hour +System.TimeOnly.get_MaxValue +System.TimeOnly.get_Microsecond +System.TimeOnly.get_Millisecond +System.TimeOnly.get_MinValue +System.TimeOnly.get_Minute +System.TimeOnly.get_Nanosecond +System.TimeOnly.get_Second +System.TimeOnly.get_Ticks +System.TimeOnly.op_Equality(System.TimeOnly,System.TimeOnly) +System.TimeOnly.op_GreaterThan(System.TimeOnly,System.TimeOnly) +System.TimeOnly.op_GreaterThanOrEqual(System.TimeOnly,System.TimeOnly) +System.TimeOnly.op_Inequality(System.TimeOnly,System.TimeOnly) +System.TimeOnly.op_LessThan(System.TimeOnly,System.TimeOnly) +System.TimeOnly.op_LessThanOrEqual(System.TimeOnly,System.TimeOnly) +System.TimeOnly.op_Subtraction(System.TimeOnly,System.TimeOnly) +System.TimeProvider +System.TimeProvider.#ctor +System.TimeProvider.CreateTimer(System.Threading.TimerCallback,System.Object,System.TimeSpan,System.TimeSpan) +System.TimeProvider.GetElapsedTime(System.Int64) +System.TimeProvider.GetElapsedTime(System.Int64,System.Int64) +System.TimeProvider.GetLocalNow +System.TimeProvider.GetTimestamp +System.TimeProvider.GetUtcNow +System.TimeProvider.get_LocalTimeZone +System.TimeProvider.get_System +System.TimeProvider.get_TimestampFrequency +System.TimeSpan +System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32) +System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) +System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +System.TimeSpan.#ctor(System.Int64) +System.TimeSpan.Add(System.TimeSpan) +System.TimeSpan.Compare(System.TimeSpan,System.TimeSpan) +System.TimeSpan.CompareTo(System.Object) +System.TimeSpan.CompareTo(System.TimeSpan) +System.TimeSpan.Divide(System.Double) +System.TimeSpan.Divide(System.TimeSpan) +System.TimeSpan.Duration +System.TimeSpan.Equals(System.Object) +System.TimeSpan.Equals(System.TimeSpan) +System.TimeSpan.Equals(System.TimeSpan,System.TimeSpan) +System.TimeSpan.FromDays(System.Double) +System.TimeSpan.FromDays(System.Int32) +System.TimeSpan.FromDays(System.Int32,System.Int32,System.Int64,System.Int64,System.Int64,System.Int64) +System.TimeSpan.FromHours(System.Double) +System.TimeSpan.FromHours(System.Int32) +System.TimeSpan.FromHours(System.Int32,System.Int64,System.Int64,System.Int64,System.Int64) +System.TimeSpan.FromMicroseconds(System.Double) +System.TimeSpan.FromMicroseconds(System.Int64) +System.TimeSpan.FromMilliseconds(System.Double) +System.TimeSpan.FromMilliseconds(System.Int64,System.Int64) +System.TimeSpan.FromMinutes(System.Double) +System.TimeSpan.FromMinutes(System.Int64) +System.TimeSpan.FromMinutes(System.Int64,System.Int64,System.Int64,System.Int64) +System.TimeSpan.FromSeconds(System.Double) +System.TimeSpan.FromSeconds(System.Int64) +System.TimeSpan.FromSeconds(System.Int64,System.Int64,System.Int64) +System.TimeSpan.FromTicks(System.Int64) +System.TimeSpan.GetHashCode +System.TimeSpan.HoursPerDay +System.TimeSpan.MaxValue +System.TimeSpan.MicrosecondsPerDay +System.TimeSpan.MicrosecondsPerHour +System.TimeSpan.MicrosecondsPerMillisecond +System.TimeSpan.MicrosecondsPerMinute +System.TimeSpan.MicrosecondsPerSecond +System.TimeSpan.MillisecondsPerDay +System.TimeSpan.MillisecondsPerHour +System.TimeSpan.MillisecondsPerMinute +System.TimeSpan.MillisecondsPerSecond +System.TimeSpan.MinValue +System.TimeSpan.MinutesPerDay +System.TimeSpan.MinutesPerHour +System.TimeSpan.Multiply(System.Double) +System.TimeSpan.NanosecondsPerTick +System.TimeSpan.Negate +System.TimeSpan.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.TimeSpan.Parse(System.String) +System.TimeSpan.Parse(System.String,System.IFormatProvider) +System.TimeSpan.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.TimeSpanStyles) +System.TimeSpan.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) +System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider) +System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles) +System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider) +System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) +System.TimeSpan.SecondsPerDay +System.TimeSpan.SecondsPerHour +System.TimeSpan.SecondsPerMinute +System.TimeSpan.Subtract(System.TimeSpan) +System.TimeSpan.TicksPerDay +System.TimeSpan.TicksPerHour +System.TimeSpan.TicksPerMicrosecond +System.TimeSpan.TicksPerMillisecond +System.TimeSpan.TicksPerMinute +System.TimeSpan.TicksPerSecond +System.TimeSpan.ToString +System.TimeSpan.ToString(System.String) +System.TimeSpan.ToString(System.String,System.IFormatProvider) +System.TimeSpan.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.TimeSpan.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.TimeSpan.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeSpan@) +System.TimeSpan.TryParse(System.ReadOnlySpan{System.Char},System.TimeSpan@) +System.TimeSpan.TryParse(System.String,System.IFormatProvider,System.TimeSpan@) +System.TimeSpan.TryParse(System.String,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.String,System.String,System.IFormatProvider,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +System.TimeSpan.TryParseExact(System.String,System.String[],System.IFormatProvider,System.TimeSpan@) +System.TimeSpan.Zero +System.TimeSpan.get_Days +System.TimeSpan.get_Hours +System.TimeSpan.get_Microseconds +System.TimeSpan.get_Milliseconds +System.TimeSpan.get_Minutes +System.TimeSpan.get_Nanoseconds +System.TimeSpan.get_Seconds +System.TimeSpan.get_Ticks +System.TimeSpan.get_TotalDays +System.TimeSpan.get_TotalHours +System.TimeSpan.get_TotalMicroseconds +System.TimeSpan.get_TotalMilliseconds +System.TimeSpan.get_TotalMinutes +System.TimeSpan.get_TotalNanoseconds +System.TimeSpan.get_TotalSeconds +System.TimeSpan.op_Addition(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_Division(System.TimeSpan,System.Double) +System.TimeSpan.op_Division(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_Equality(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_GreaterThan(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_GreaterThanOrEqual(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_Inequality(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_LessThan(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_LessThanOrEqual(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_Multiply(System.Double,System.TimeSpan) +System.TimeSpan.op_Multiply(System.TimeSpan,System.Double) +System.TimeSpan.op_Subtraction(System.TimeSpan,System.TimeSpan) +System.TimeSpan.op_UnaryNegation(System.TimeSpan) +System.TimeSpan.op_UnaryPlus(System.TimeSpan) +System.TimeZone +System.TimeZone.#ctor +System.TimeZone.GetDaylightChanges(System.Int32) +System.TimeZone.GetUtcOffset(System.DateTime) +System.TimeZone.IsDaylightSavingTime(System.DateTime) +System.TimeZone.IsDaylightSavingTime(System.DateTime,System.Globalization.DaylightTime) +System.TimeZone.ToLocalTime(System.DateTime) +System.TimeZone.ToUniversalTime(System.DateTime) +System.TimeZone.get_CurrentTimeZone +System.TimeZone.get_DaylightName +System.TimeZone.get_StandardName +System.TimeZoneInfo +System.TimeZoneInfo.AdjustmentRule +System.TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) +System.TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime,System.TimeSpan) +System.TimeZoneInfo.AdjustmentRule.Equals(System.Object) +System.TimeZoneInfo.AdjustmentRule.Equals(System.TimeZoneInfo.AdjustmentRule) +System.TimeZoneInfo.AdjustmentRule.GetHashCode +System.TimeZoneInfo.AdjustmentRule.get_BaseUtcOffsetDelta +System.TimeZoneInfo.AdjustmentRule.get_DateEnd +System.TimeZoneInfo.AdjustmentRule.get_DateStart +System.TimeZoneInfo.AdjustmentRule.get_DaylightDelta +System.TimeZoneInfo.AdjustmentRule.get_DaylightTransitionEnd +System.TimeZoneInfo.AdjustmentRule.get_DaylightTransitionStart +System.TimeZoneInfo.ClearCachedData +System.TimeZoneInfo.ConvertTime(System.DateTime,System.TimeZoneInfo) +System.TimeZoneInfo.ConvertTime(System.DateTime,System.TimeZoneInfo,System.TimeZoneInfo) +System.TimeZoneInfo.ConvertTime(System.DateTimeOffset,System.TimeZoneInfo) +System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTime,System.String) +System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTime,System.String,System.String) +System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTimeOffset,System.String) +System.TimeZoneInfo.ConvertTimeFromUtc(System.DateTime,System.TimeZoneInfo) +System.TimeZoneInfo.ConvertTimeToUtc(System.DateTime) +System.TimeZoneInfo.ConvertTimeToUtc(System.DateTime,System.TimeZoneInfo) +System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String) +System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo.AdjustmentRule[]) +System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo.AdjustmentRule[],System.Boolean) +System.TimeZoneInfo.Equals(System.Object) +System.TimeZoneInfo.Equals(System.TimeZoneInfo) +System.TimeZoneInfo.FindSystemTimeZoneById(System.String) +System.TimeZoneInfo.FromSerializedString(System.String) +System.TimeZoneInfo.GetAdjustmentRules +System.TimeZoneInfo.GetAmbiguousTimeOffsets(System.DateTime) +System.TimeZoneInfo.GetAmbiguousTimeOffsets(System.DateTimeOffset) +System.TimeZoneInfo.GetHashCode +System.TimeZoneInfo.GetSystemTimeZones +System.TimeZoneInfo.GetSystemTimeZones(System.Boolean) +System.TimeZoneInfo.GetUtcOffset(System.DateTime) +System.TimeZoneInfo.GetUtcOffset(System.DateTimeOffset) +System.TimeZoneInfo.HasSameRules(System.TimeZoneInfo) +System.TimeZoneInfo.IsAmbiguousTime(System.DateTime) +System.TimeZoneInfo.IsAmbiguousTime(System.DateTimeOffset) +System.TimeZoneInfo.IsDaylightSavingTime(System.DateTime) +System.TimeZoneInfo.IsDaylightSavingTime(System.DateTimeOffset) +System.TimeZoneInfo.IsInvalidTime(System.DateTime) +System.TimeZoneInfo.ToSerializedString +System.TimeZoneInfo.ToString +System.TimeZoneInfo.TransitionTime +System.TimeZoneInfo.TransitionTime.CreateFixedDateRule(System.DateTime,System.Int32,System.Int32) +System.TimeZoneInfo.TransitionTime.CreateFloatingDateRule(System.DateTime,System.Int32,System.Int32,System.DayOfWeek) +System.TimeZoneInfo.TransitionTime.Equals(System.Object) +System.TimeZoneInfo.TransitionTime.Equals(System.TimeZoneInfo.TransitionTime) +System.TimeZoneInfo.TransitionTime.GetHashCode +System.TimeZoneInfo.TransitionTime.get_Day +System.TimeZoneInfo.TransitionTime.get_DayOfWeek +System.TimeZoneInfo.TransitionTime.get_IsFixedDateRule +System.TimeZoneInfo.TransitionTime.get_Month +System.TimeZoneInfo.TransitionTime.get_TimeOfDay +System.TimeZoneInfo.TransitionTime.get_Week +System.TimeZoneInfo.TransitionTime.op_Equality(System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) +System.TimeZoneInfo.TransitionTime.op_Inequality(System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) +System.TimeZoneInfo.TryConvertIanaIdToWindowsId(System.String,System.String@) +System.TimeZoneInfo.TryConvertWindowsIdToIanaId(System.String,System.String,System.String@) +System.TimeZoneInfo.TryConvertWindowsIdToIanaId(System.String,System.String@) +System.TimeZoneInfo.TryFindSystemTimeZoneById(System.String,System.TimeZoneInfo@) +System.TimeZoneInfo.get_BaseUtcOffset +System.TimeZoneInfo.get_DaylightName +System.TimeZoneInfo.get_DisplayName +System.TimeZoneInfo.get_HasIanaId +System.TimeZoneInfo.get_Id +System.TimeZoneInfo.get_Local +System.TimeZoneInfo.get_StandardName +System.TimeZoneInfo.get_SupportsDaylightSavingTime +System.TimeZoneInfo.get_Utc +System.TimeZoneNotFoundException +System.TimeZoneNotFoundException.#ctor +System.TimeZoneNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TimeZoneNotFoundException.#ctor(System.String) +System.TimeZoneNotFoundException.#ctor(System.String,System.Exception) +System.TimeoutException +System.TimeoutException.#ctor +System.TimeoutException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TimeoutException.#ctor(System.String) +System.TimeoutException.#ctor(System.String,System.Exception) +System.Tuple +System.Tuple.Create``1(``0) +System.Tuple.Create``2(``0,``1) +System.Tuple.Create``3(``0,``1,``2) +System.Tuple.Create``4(``0,``1,``2,``3) +System.Tuple.Create``5(``0,``1,``2,``3,``4) +System.Tuple.Create``6(``0,``1,``2,``3,``4,``5) +System.Tuple.Create``7(``0,``1,``2,``3,``4,``5,``6) +System.Tuple.Create``8(``0,``1,``2,``3,``4,``5,``6,``7) +System.TupleExtensions +System.TupleExtensions.Deconstruct``1(System.Tuple{``0},``0@) +System.TupleExtensions.Deconstruct``10(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@) +System.TupleExtensions.Deconstruct``11(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@) +System.TupleExtensions.Deconstruct``12(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@) +System.TupleExtensions.Deconstruct``13(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@) +System.TupleExtensions.Deconstruct``14(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@) +System.TupleExtensions.Deconstruct``15(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@) +System.TupleExtensions.Deconstruct``16(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@) +System.TupleExtensions.Deconstruct``17(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@) +System.TupleExtensions.Deconstruct``18(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@) +System.TupleExtensions.Deconstruct``19(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@) +System.TupleExtensions.Deconstruct``2(System.Tuple{``0,``1},``0@,``1@) +System.TupleExtensions.Deconstruct``20(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@,``19@) +System.TupleExtensions.Deconstruct``21(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19,``20}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@,``19@,``20@) +System.TupleExtensions.Deconstruct``3(System.Tuple{``0,``1,``2},``0@,``1@,``2@) +System.TupleExtensions.Deconstruct``4(System.Tuple{``0,``1,``2,``3},``0@,``1@,``2@,``3@) +System.TupleExtensions.Deconstruct``5(System.Tuple{``0,``1,``2,``3,``4},``0@,``1@,``2@,``3@,``4@) +System.TupleExtensions.Deconstruct``6(System.Tuple{``0,``1,``2,``3,``4,``5},``0@,``1@,``2@,``3@,``4@,``5@) +System.TupleExtensions.Deconstruct``7(System.Tuple{``0,``1,``2,``3,``4,``5,``6},``0@,``1@,``2@,``3@,``4@,``5@,``6@) +System.TupleExtensions.Deconstruct``8(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@) +System.TupleExtensions.Deconstruct``9(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@) +System.TupleExtensions.ToTuple``1(System.ValueTuple{``0}) +System.TupleExtensions.ToTuple``10(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9}}) +System.TupleExtensions.ToTuple``11(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10}}) +System.TupleExtensions.ToTuple``12(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11}}) +System.TupleExtensions.ToTuple``13(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12}}) +System.TupleExtensions.ToTuple``14(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13}}) +System.TupleExtensions.ToTuple``15(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14}}}) +System.TupleExtensions.ToTuple``16(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15}}}) +System.TupleExtensions.ToTuple``17(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16}}}) +System.TupleExtensions.ToTuple``18(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17}}}) +System.TupleExtensions.ToTuple``19(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18}}}) +System.TupleExtensions.ToTuple``2(System.ValueTuple{``0,``1}) +System.TupleExtensions.ToTuple``20(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18,``19}}}) +System.TupleExtensions.ToTuple``21(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18,``19,``20}}}) +System.TupleExtensions.ToTuple``3(System.ValueTuple{``0,``1,``2}) +System.TupleExtensions.ToTuple``4(System.ValueTuple{``0,``1,``2,``3}) +System.TupleExtensions.ToTuple``5(System.ValueTuple{``0,``1,``2,``3,``4}) +System.TupleExtensions.ToTuple``6(System.ValueTuple{``0,``1,``2,``3,``4,``5}) +System.TupleExtensions.ToTuple``7(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6}) +System.TupleExtensions.ToTuple``8(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7}}) +System.TupleExtensions.ToTuple``9(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8}}) +System.TupleExtensions.ToValueTuple``1(System.Tuple{``0}) +System.TupleExtensions.ToValueTuple``10(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9}}) +System.TupleExtensions.ToValueTuple``11(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10}}) +System.TupleExtensions.ToValueTuple``12(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11}}) +System.TupleExtensions.ToValueTuple``13(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12}}) +System.TupleExtensions.ToValueTuple``14(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13}}) +System.TupleExtensions.ToValueTuple``15(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14}}}) +System.TupleExtensions.ToValueTuple``16(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15}}}) +System.TupleExtensions.ToValueTuple``17(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16}}}) +System.TupleExtensions.ToValueTuple``18(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17}}}) +System.TupleExtensions.ToValueTuple``19(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18}}}) +System.TupleExtensions.ToValueTuple``2(System.Tuple{``0,``1}) +System.TupleExtensions.ToValueTuple``20(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19}}}) +System.TupleExtensions.ToValueTuple``21(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19,``20}}}) +System.TupleExtensions.ToValueTuple``3(System.Tuple{``0,``1,``2}) +System.TupleExtensions.ToValueTuple``4(System.Tuple{``0,``1,``2,``3}) +System.TupleExtensions.ToValueTuple``5(System.Tuple{``0,``1,``2,``3,``4}) +System.TupleExtensions.ToValueTuple``6(System.Tuple{``0,``1,``2,``3,``4,``5}) +System.TupleExtensions.ToValueTuple``7(System.Tuple{``0,``1,``2,``3,``4,``5,``6}) +System.TupleExtensions.ToValueTuple``8(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7}}) +System.TupleExtensions.ToValueTuple``9(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8}}) +System.Tuple`1 +System.Tuple`1.#ctor(`0) +System.Tuple`1.Equals(System.Object) +System.Tuple`1.GetHashCode +System.Tuple`1.ToString +System.Tuple`1.get_Item1 +System.Tuple`2 +System.Tuple`2.#ctor(`0,`1) +System.Tuple`2.Equals(System.Object) +System.Tuple`2.GetHashCode +System.Tuple`2.ToString +System.Tuple`2.get_Item1 +System.Tuple`2.get_Item2 +System.Tuple`3 +System.Tuple`3.#ctor(`0,`1,`2) +System.Tuple`3.Equals(System.Object) +System.Tuple`3.GetHashCode +System.Tuple`3.ToString +System.Tuple`3.get_Item1 +System.Tuple`3.get_Item2 +System.Tuple`3.get_Item3 +System.Tuple`4 +System.Tuple`4.#ctor(`0,`1,`2,`3) +System.Tuple`4.Equals(System.Object) +System.Tuple`4.GetHashCode +System.Tuple`4.ToString +System.Tuple`4.get_Item1 +System.Tuple`4.get_Item2 +System.Tuple`4.get_Item3 +System.Tuple`4.get_Item4 +System.Tuple`5 +System.Tuple`5.#ctor(`0,`1,`2,`3,`4) +System.Tuple`5.Equals(System.Object) +System.Tuple`5.GetHashCode +System.Tuple`5.ToString +System.Tuple`5.get_Item1 +System.Tuple`5.get_Item2 +System.Tuple`5.get_Item3 +System.Tuple`5.get_Item4 +System.Tuple`5.get_Item5 +System.Tuple`6 +System.Tuple`6.#ctor(`0,`1,`2,`3,`4,`5) +System.Tuple`6.Equals(System.Object) +System.Tuple`6.GetHashCode +System.Tuple`6.ToString +System.Tuple`6.get_Item1 +System.Tuple`6.get_Item2 +System.Tuple`6.get_Item3 +System.Tuple`6.get_Item4 +System.Tuple`6.get_Item5 +System.Tuple`6.get_Item6 +System.Tuple`7 +System.Tuple`7.#ctor(`0,`1,`2,`3,`4,`5,`6) +System.Tuple`7.Equals(System.Object) +System.Tuple`7.GetHashCode +System.Tuple`7.ToString +System.Tuple`7.get_Item1 +System.Tuple`7.get_Item2 +System.Tuple`7.get_Item3 +System.Tuple`7.get_Item4 +System.Tuple`7.get_Item5 +System.Tuple`7.get_Item6 +System.Tuple`7.get_Item7 +System.Tuple`8 +System.Tuple`8.#ctor(`0,`1,`2,`3,`4,`5,`6,`7) +System.Tuple`8.Equals(System.Object) +System.Tuple`8.GetHashCode +System.Tuple`8.ToString +System.Tuple`8.get_Item1 +System.Tuple`8.get_Item2 +System.Tuple`8.get_Item3 +System.Tuple`8.get_Item4 +System.Tuple`8.get_Item5 +System.Tuple`8.get_Item6 +System.Tuple`8.get_Item7 +System.Tuple`8.get_Rest +System.Type +System.Type.Delimiter +System.Type.EmptyTypes +System.Type.FilterAttribute +System.Type.FilterName +System.Type.FilterNameIgnoreCase +System.Type.Missing +System.TypeAccessException +System.TypeAccessException.#ctor +System.TypeAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TypeAccessException.#ctor(System.String) +System.TypeAccessException.#ctor(System.String,System.Exception) +System.TypeCode +System.TypeCode.Boolean +System.TypeCode.Byte +System.TypeCode.Char +System.TypeCode.DBNull +System.TypeCode.DateTime +System.TypeCode.Decimal +System.TypeCode.Double +System.TypeCode.Empty +System.TypeCode.Int16 +System.TypeCode.Int32 +System.TypeCode.Int64 +System.TypeCode.Object +System.TypeCode.SByte +System.TypeCode.Single +System.TypeCode.String +System.TypeCode.UInt16 +System.TypeCode.UInt32 +System.TypeCode.UInt64 +System.TypeInitializationException +System.TypeInitializationException.#ctor(System.String,System.Exception) +System.TypeInitializationException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TypeInitializationException.get_TypeName +System.TypeLoadException +System.TypeLoadException.#ctor +System.TypeLoadException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TypeLoadException.#ctor(System.String) +System.TypeLoadException.#ctor(System.String,System.Exception) +System.TypeLoadException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TypeLoadException.get_Message +System.TypeLoadException.get_TypeName +System.TypeUnloadedException +System.TypeUnloadedException.#ctor +System.TypeUnloadedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.TypeUnloadedException.#ctor(System.String) +System.TypeUnloadedException.#ctor(System.String,System.Exception) +System.TypedReference +System.TypedReference.Equals(System.Object) +System.TypedReference.GetHashCode +System.TypedReference.GetTargetType(System.TypedReference) +System.TypedReference.MakeTypedReference(System.Object,System.Reflection.FieldInfo[]) +System.TypedReference.SetTypedReference(System.TypedReference,System.Object) +System.TypedReference.TargetTypeToken(System.TypedReference) +System.TypedReference.ToObject(System.TypedReference) +System.UInt128 +System.UInt128.#ctor(System.UInt64,System.UInt64) +System.UInt128.Clamp(System.UInt128,System.UInt128,System.UInt128) +System.UInt128.CompareTo(System.Object) +System.UInt128.CompareTo(System.UInt128) +System.UInt128.CreateChecked``1(``0) +System.UInt128.CreateSaturating``1(``0) +System.UInt128.CreateTruncating``1(``0) +System.UInt128.DivRem(System.UInt128,System.UInt128) +System.UInt128.Equals(System.Object) +System.UInt128.Equals(System.UInt128) +System.UInt128.GetHashCode +System.UInt128.IsEvenInteger(System.UInt128) +System.UInt128.IsOddInteger(System.UInt128) +System.UInt128.IsPow2(System.UInt128) +System.UInt128.LeadingZeroCount(System.UInt128) +System.UInt128.Log2(System.UInt128) +System.UInt128.Max(System.UInt128,System.UInt128) +System.UInt128.Min(System.UInt128,System.UInt128) +System.UInt128.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt128.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.UInt128.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt128.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt128.Parse(System.String) +System.UInt128.Parse(System.String,System.Globalization.NumberStyles) +System.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt128.Parse(System.String,System.IFormatProvider) +System.UInt128.PopCount(System.UInt128) +System.UInt128.RotateLeft(System.UInt128,System.Int32) +System.UInt128.RotateRight(System.UInt128,System.Int32) +System.UInt128.Sign(System.UInt128) +System.UInt128.ToString +System.UInt128.ToString(System.IFormatProvider) +System.UInt128.ToString(System.String) +System.UInt128.ToString(System.String,System.IFormatProvider) +System.UInt128.TrailingZeroCount(System.UInt128) +System.UInt128.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt128.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) +System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt128@) +System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.UInt128@) +System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) +System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt128@) +System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.UInt128@) +System.UInt128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) +System.UInt128.TryParse(System.String,System.IFormatProvider,System.UInt128@) +System.UInt128.TryParse(System.String,System.UInt128@) +System.UInt128.get_MaxValue +System.UInt128.get_MinValue +System.UInt128.get_One +System.UInt128.get_Zero +System.UInt128.op_Addition(System.UInt128,System.UInt128) +System.UInt128.op_BitwiseAnd(System.UInt128,System.UInt128) +System.UInt128.op_BitwiseOr(System.UInt128,System.UInt128) +System.UInt128.op_CheckedAddition(System.UInt128,System.UInt128) +System.UInt128.op_CheckedDecrement(System.UInt128) +System.UInt128.op_CheckedDivision(System.UInt128,System.UInt128) +System.UInt128.op_CheckedExplicit(System.Double)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.Int16)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.Int32)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.Int64)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.IntPtr)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.SByte)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.Single)~System.UInt128 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.Byte +System.UInt128.op_CheckedExplicit(System.UInt128)~System.Char +System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int128 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int16 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int32 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int64 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.IntPtr +System.UInt128.op_CheckedExplicit(System.UInt128)~System.SByte +System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt16 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt32 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt64 +System.UInt128.op_CheckedExplicit(System.UInt128)~System.UIntPtr +System.UInt128.op_CheckedIncrement(System.UInt128) +System.UInt128.op_CheckedMultiply(System.UInt128,System.UInt128) +System.UInt128.op_CheckedSubtraction(System.UInt128,System.UInt128) +System.UInt128.op_CheckedUnaryNegation(System.UInt128) +System.UInt128.op_Decrement(System.UInt128) +System.UInt128.op_Division(System.UInt128,System.UInt128) +System.UInt128.op_Equality(System.UInt128,System.UInt128) +System.UInt128.op_ExclusiveOr(System.UInt128,System.UInt128) +System.UInt128.op_Explicit(System.Decimal)~System.UInt128 +System.UInt128.op_Explicit(System.Double)~System.UInt128 +System.UInt128.op_Explicit(System.Int16)~System.UInt128 +System.UInt128.op_Explicit(System.Int32)~System.UInt128 +System.UInt128.op_Explicit(System.Int64)~System.UInt128 +System.UInt128.op_Explicit(System.IntPtr)~System.UInt128 +System.UInt128.op_Explicit(System.SByte)~System.UInt128 +System.UInt128.op_Explicit(System.Single)~System.UInt128 +System.UInt128.op_Explicit(System.UInt128)~System.Byte +System.UInt128.op_Explicit(System.UInt128)~System.Char +System.UInt128.op_Explicit(System.UInt128)~System.Decimal +System.UInt128.op_Explicit(System.UInt128)~System.Double +System.UInt128.op_Explicit(System.UInt128)~System.Half +System.UInt128.op_Explicit(System.UInt128)~System.Int128 +System.UInt128.op_Explicit(System.UInt128)~System.Int16 +System.UInt128.op_Explicit(System.UInt128)~System.Int32 +System.UInt128.op_Explicit(System.UInt128)~System.Int64 +System.UInt128.op_Explicit(System.UInt128)~System.IntPtr +System.UInt128.op_Explicit(System.UInt128)~System.SByte +System.UInt128.op_Explicit(System.UInt128)~System.Single +System.UInt128.op_Explicit(System.UInt128)~System.UInt16 +System.UInt128.op_Explicit(System.UInt128)~System.UInt32 +System.UInt128.op_Explicit(System.UInt128)~System.UInt64 +System.UInt128.op_Explicit(System.UInt128)~System.UIntPtr +System.UInt128.op_GreaterThan(System.UInt128,System.UInt128) +System.UInt128.op_GreaterThanOrEqual(System.UInt128,System.UInt128) +System.UInt128.op_Implicit(System.Byte)~System.UInt128 +System.UInt128.op_Implicit(System.Char)~System.UInt128 +System.UInt128.op_Implicit(System.UInt16)~System.UInt128 +System.UInt128.op_Implicit(System.UInt32)~System.UInt128 +System.UInt128.op_Implicit(System.UInt64)~System.UInt128 +System.UInt128.op_Implicit(System.UIntPtr)~System.UInt128 +System.UInt128.op_Increment(System.UInt128) +System.UInt128.op_Inequality(System.UInt128,System.UInt128) +System.UInt128.op_LeftShift(System.UInt128,System.Int32) +System.UInt128.op_LessThan(System.UInt128,System.UInt128) +System.UInt128.op_LessThanOrEqual(System.UInt128,System.UInt128) +System.UInt128.op_Modulus(System.UInt128,System.UInt128) +System.UInt128.op_Multiply(System.UInt128,System.UInt128) +System.UInt128.op_OnesComplement(System.UInt128) +System.UInt128.op_RightShift(System.UInt128,System.Int32) +System.UInt128.op_Subtraction(System.UInt128,System.UInt128) +System.UInt128.op_UnaryNegation(System.UInt128) +System.UInt128.op_UnaryPlus(System.UInt128) +System.UInt128.op_UnsignedRightShift(System.UInt128,System.Int32) +System.UInt16 +System.UInt16.Clamp(System.UInt16,System.UInt16,System.UInt16) +System.UInt16.CompareTo(System.Object) +System.UInt16.CompareTo(System.UInt16) +System.UInt16.CreateChecked``1(``0) +System.UInt16.CreateSaturating``1(``0) +System.UInt16.CreateTruncating``1(``0) +System.UInt16.DivRem(System.UInt16,System.UInt16) +System.UInt16.Equals(System.Object) +System.UInt16.Equals(System.UInt16) +System.UInt16.GetHashCode +System.UInt16.GetTypeCode +System.UInt16.IsEvenInteger(System.UInt16) +System.UInt16.IsOddInteger(System.UInt16) +System.UInt16.IsPow2(System.UInt16) +System.UInt16.LeadingZeroCount(System.UInt16) +System.UInt16.Log2(System.UInt16) +System.UInt16.Max(System.UInt16,System.UInt16) +System.UInt16.MaxValue +System.UInt16.Min(System.UInt16,System.UInt16) +System.UInt16.MinValue +System.UInt16.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt16.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.UInt16.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt16.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt16.Parse(System.String) +System.UInt16.Parse(System.String,System.Globalization.NumberStyles) +System.UInt16.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt16.Parse(System.String,System.IFormatProvider) +System.UInt16.PopCount(System.UInt16) +System.UInt16.RotateLeft(System.UInt16,System.Int32) +System.UInt16.RotateRight(System.UInt16,System.Int32) +System.UInt16.Sign(System.UInt16) +System.UInt16.ToString +System.UInt16.ToString(System.IFormatProvider) +System.UInt16.ToString(System.String) +System.UInt16.ToString(System.String,System.IFormatProvider) +System.UInt16.TrailingZeroCount(System.UInt16) +System.UInt16.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt16.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) +System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt16@) +System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.UInt16@) +System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) +System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt16@) +System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.UInt16@) +System.UInt16.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) +System.UInt16.TryParse(System.String,System.IFormatProvider,System.UInt16@) +System.UInt16.TryParse(System.String,System.UInt16@) +System.UInt32 +System.UInt32.BigMul(System.UInt32,System.UInt32) +System.UInt32.Clamp(System.UInt32,System.UInt32,System.UInt32) +System.UInt32.CompareTo(System.Object) +System.UInt32.CompareTo(System.UInt32) +System.UInt32.CreateChecked``1(``0) +System.UInt32.CreateSaturating``1(``0) +System.UInt32.CreateTruncating``1(``0) +System.UInt32.DivRem(System.UInt32,System.UInt32) +System.UInt32.Equals(System.Object) +System.UInt32.Equals(System.UInt32) +System.UInt32.GetHashCode +System.UInt32.GetTypeCode +System.UInt32.IsEvenInteger(System.UInt32) +System.UInt32.IsOddInteger(System.UInt32) +System.UInt32.IsPow2(System.UInt32) +System.UInt32.LeadingZeroCount(System.UInt32) +System.UInt32.Log2(System.UInt32) +System.UInt32.Max(System.UInt32,System.UInt32) +System.UInt32.MaxValue +System.UInt32.Min(System.UInt32,System.UInt32) +System.UInt32.MinValue +System.UInt32.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt32.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.UInt32.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt32.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt32.Parse(System.String) +System.UInt32.Parse(System.String,System.Globalization.NumberStyles) +System.UInt32.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt32.Parse(System.String,System.IFormatProvider) +System.UInt32.PopCount(System.UInt32) +System.UInt32.RotateLeft(System.UInt32,System.Int32) +System.UInt32.RotateRight(System.UInt32,System.Int32) +System.UInt32.Sign(System.UInt32) +System.UInt32.ToString +System.UInt32.ToString(System.IFormatProvider) +System.UInt32.ToString(System.String) +System.UInt32.ToString(System.String,System.IFormatProvider) +System.UInt32.TrailingZeroCount(System.UInt32) +System.UInt32.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt32.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) +System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt32@) +System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.UInt32@) +System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) +System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt32@) +System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.UInt32@) +System.UInt32.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) +System.UInt32.TryParse(System.String,System.IFormatProvider,System.UInt32@) +System.UInt32.TryParse(System.String,System.UInt32@) +System.UInt64 +System.UInt64.BigMul(System.UInt64,System.UInt64) +System.UInt64.Clamp(System.UInt64,System.UInt64,System.UInt64) +System.UInt64.CompareTo(System.Object) +System.UInt64.CompareTo(System.UInt64) +System.UInt64.CreateChecked``1(``0) +System.UInt64.CreateSaturating``1(``0) +System.UInt64.CreateTruncating``1(``0) +System.UInt64.DivRem(System.UInt64,System.UInt64) +System.UInt64.Equals(System.Object) +System.UInt64.Equals(System.UInt64) +System.UInt64.GetHashCode +System.UInt64.GetTypeCode +System.UInt64.IsEvenInteger(System.UInt64) +System.UInt64.IsOddInteger(System.UInt64) +System.UInt64.IsPow2(System.UInt64) +System.UInt64.LeadingZeroCount(System.UInt64) +System.UInt64.Log2(System.UInt64) +System.UInt64.Max(System.UInt64,System.UInt64) +System.UInt64.MaxValue +System.UInt64.Min(System.UInt64,System.UInt64) +System.UInt64.MinValue +System.UInt64.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt64.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.UInt64.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt64.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt64.Parse(System.String) +System.UInt64.Parse(System.String,System.Globalization.NumberStyles) +System.UInt64.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.UInt64.Parse(System.String,System.IFormatProvider) +System.UInt64.PopCount(System.UInt64) +System.UInt64.RotateLeft(System.UInt64,System.Int32) +System.UInt64.RotateRight(System.UInt64,System.Int32) +System.UInt64.Sign(System.UInt64) +System.UInt64.ToString +System.UInt64.ToString(System.IFormatProvider) +System.UInt64.ToString(System.String) +System.UInt64.ToString(System.String,System.IFormatProvider) +System.UInt64.TrailingZeroCount(System.UInt64) +System.UInt64.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt64.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) +System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt64@) +System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.UInt64@) +System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) +System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt64@) +System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.UInt64@) +System.UInt64.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) +System.UInt64.TryParse(System.String,System.IFormatProvider,System.UInt64@) +System.UInt64.TryParse(System.String,System.UInt64@) +System.UIntPtr +System.UIntPtr.#ctor(System.UInt32) +System.UIntPtr.#ctor(System.UInt64) +System.UIntPtr.#ctor(System.Void*) +System.UIntPtr.Add(System.UIntPtr,System.Int32) +System.UIntPtr.Clamp(System.UIntPtr,System.UIntPtr,System.UIntPtr) +System.UIntPtr.CompareTo(System.Object) +System.UIntPtr.CompareTo(System.UIntPtr) +System.UIntPtr.CreateChecked``1(``0) +System.UIntPtr.CreateSaturating``1(``0) +System.UIntPtr.CreateTruncating``1(``0) +System.UIntPtr.DivRem(System.UIntPtr,System.UIntPtr) +System.UIntPtr.Equals(System.Object) +System.UIntPtr.Equals(System.UIntPtr) +System.UIntPtr.GetHashCode +System.UIntPtr.IsEvenInteger(System.UIntPtr) +System.UIntPtr.IsOddInteger(System.UIntPtr) +System.UIntPtr.IsPow2(System.UIntPtr) +System.UIntPtr.LeadingZeroCount(System.UIntPtr) +System.UIntPtr.Log2(System.UIntPtr) +System.UIntPtr.Max(System.UIntPtr,System.UIntPtr) +System.UIntPtr.Min(System.UIntPtr,System.UIntPtr) +System.UIntPtr.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +System.UIntPtr.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +System.UIntPtr.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +System.UIntPtr.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UIntPtr.Parse(System.String) +System.UIntPtr.Parse(System.String,System.Globalization.NumberStyles) +System.UIntPtr.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +System.UIntPtr.Parse(System.String,System.IFormatProvider) +System.UIntPtr.PopCount(System.UIntPtr) +System.UIntPtr.RotateLeft(System.UIntPtr,System.Int32) +System.UIntPtr.RotateRight(System.UIntPtr,System.Int32) +System.UIntPtr.Sign(System.UIntPtr) +System.UIntPtr.Subtract(System.UIntPtr,System.Int32) +System.UIntPtr.ToPointer +System.UIntPtr.ToString +System.UIntPtr.ToString(System.IFormatProvider) +System.UIntPtr.ToString(System.String) +System.UIntPtr.ToString(System.String,System.IFormatProvider) +System.UIntPtr.ToUInt32 +System.UIntPtr.ToUInt64 +System.UIntPtr.TrailingZeroCount(System.UIntPtr) +System.UIntPtr.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UIntPtr.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) +System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UIntPtr@) +System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.UIntPtr@) +System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) +System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UIntPtr@) +System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.UIntPtr@) +System.UIntPtr.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) +System.UIntPtr.TryParse(System.String,System.IFormatProvider,System.UIntPtr@) +System.UIntPtr.TryParse(System.String,System.UIntPtr@) +System.UIntPtr.Zero +System.UIntPtr.get_MaxValue +System.UIntPtr.get_MinValue +System.UIntPtr.get_Size +System.UIntPtr.op_Addition(System.UIntPtr,System.Int32) +System.UIntPtr.op_Equality(System.UIntPtr,System.UIntPtr) +System.UIntPtr.op_Explicit(System.UInt32)~System.UIntPtr +System.UIntPtr.op_Explicit(System.UInt64)~System.UIntPtr +System.UIntPtr.op_Explicit(System.UIntPtr)~System.UInt32 +System.UIntPtr.op_Explicit(System.UIntPtr)~System.UInt64 +System.UIntPtr.op_Explicit(System.UIntPtr)~System.Void* +System.UIntPtr.op_Explicit(System.Void*)~System.UIntPtr +System.UIntPtr.op_Inequality(System.UIntPtr,System.UIntPtr) +System.UIntPtr.op_Subtraction(System.UIntPtr,System.Int32) +System.UnauthorizedAccessException +System.UnauthorizedAccessException.#ctor +System.UnauthorizedAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.UnauthorizedAccessException.#ctor(System.String) +System.UnauthorizedAccessException.#ctor(System.String,System.Exception) +System.UnhandledExceptionEventArgs +System.UnhandledExceptionEventArgs.#ctor(System.Object,System.Boolean) +System.UnhandledExceptionEventArgs.get_ExceptionObject +System.UnhandledExceptionEventArgs.get_IsTerminating +System.UnhandledExceptionEventHandler +System.UnhandledExceptionEventHandler.#ctor(System.Object,System.IntPtr) +System.UnhandledExceptionEventHandler.BeginInvoke(System.Object,System.UnhandledExceptionEventArgs,System.AsyncCallback,System.Object) +System.UnhandledExceptionEventHandler.EndInvoke(System.IAsyncResult) +System.UnhandledExceptionEventHandler.Invoke(System.Object,System.UnhandledExceptionEventArgs) +System.Uri +System.Uri.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Uri.#ctor(System.String) +System.Uri.#ctor(System.String,System.Boolean) +System.Uri.#ctor(System.String,System.UriCreationOptions@) +System.Uri.#ctor(System.String,System.UriKind) +System.Uri.#ctor(System.Uri,System.String) +System.Uri.#ctor(System.Uri,System.String,System.Boolean) +System.Uri.#ctor(System.Uri,System.Uri) +System.Uri.Canonicalize +System.Uri.CheckHostName(System.String) +System.Uri.CheckSchemeName(System.String) +System.Uri.CheckSecurity +System.Uri.Compare(System.Uri,System.Uri,System.UriComponents,System.UriFormat,System.StringComparison) +System.Uri.Equals(System.Object) +System.Uri.Equals(System.Uri) +System.Uri.Escape +System.Uri.EscapeDataString(System.ReadOnlySpan{System.Char}) +System.Uri.EscapeDataString(System.String) +System.Uri.EscapeString(System.String) +System.Uri.EscapeUriString(System.String) +System.Uri.FromHex(System.Char) +System.Uri.GetComponents(System.UriComponents,System.UriFormat) +System.Uri.GetHashCode +System.Uri.GetLeftPart(System.UriPartial) +System.Uri.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.Uri.HexEscape(System.Char) +System.Uri.HexUnescape(System.String,System.Int32@) +System.Uri.IsBadFileSystemCharacter(System.Char) +System.Uri.IsBaseOf(System.Uri) +System.Uri.IsExcludedCharacter(System.Char) +System.Uri.IsHexDigit(System.Char) +System.Uri.IsHexEncoding(System.String,System.Int32) +System.Uri.IsReservedCharacter(System.Char) +System.Uri.IsWellFormedOriginalString +System.Uri.IsWellFormedUriString(System.String,System.UriKind) +System.Uri.MakeRelative(System.Uri) +System.Uri.MakeRelativeUri(System.Uri) +System.Uri.Parse +System.Uri.SchemeDelimiter +System.Uri.ToString +System.Uri.TryCreate(System.String,System.UriCreationOptions@,System.Uri@) +System.Uri.TryCreate(System.String,System.UriKind,System.Uri@) +System.Uri.TryCreate(System.Uri,System.String,System.Uri@) +System.Uri.TryCreate(System.Uri,System.Uri,System.Uri@) +System.Uri.TryEscapeDataString(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) +System.Uri.TryFormat(System.Span{System.Char},System.Int32@) +System.Uri.TryUnescapeDataString(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) +System.Uri.Unescape(System.String) +System.Uri.UnescapeDataString(System.ReadOnlySpan{System.Char}) +System.Uri.UnescapeDataString(System.String) +System.Uri.UriSchemeFile +System.Uri.UriSchemeFtp +System.Uri.UriSchemeFtps +System.Uri.UriSchemeGopher +System.Uri.UriSchemeHttp +System.Uri.UriSchemeHttps +System.Uri.UriSchemeMailto +System.Uri.UriSchemeNetPipe +System.Uri.UriSchemeNetTcp +System.Uri.UriSchemeNews +System.Uri.UriSchemeNntp +System.Uri.UriSchemeSftp +System.Uri.UriSchemeSsh +System.Uri.UriSchemeTelnet +System.Uri.UriSchemeWs +System.Uri.UriSchemeWss +System.Uri.get_AbsolutePath +System.Uri.get_AbsoluteUri +System.Uri.get_Authority +System.Uri.get_DnsSafeHost +System.Uri.get_Fragment +System.Uri.get_Host +System.Uri.get_HostNameType +System.Uri.get_IdnHost +System.Uri.get_IsAbsoluteUri +System.Uri.get_IsDefaultPort +System.Uri.get_IsFile +System.Uri.get_IsLoopback +System.Uri.get_IsUnc +System.Uri.get_LocalPath +System.Uri.get_OriginalString +System.Uri.get_PathAndQuery +System.Uri.get_Port +System.Uri.get_Query +System.Uri.get_Scheme +System.Uri.get_Segments +System.Uri.get_UserEscaped +System.Uri.get_UserInfo +System.Uri.op_Equality(System.Uri,System.Uri) +System.Uri.op_Inequality(System.Uri,System.Uri) +System.UriBuilder +System.UriBuilder.#ctor +System.UriBuilder.#ctor(System.String) +System.UriBuilder.#ctor(System.String,System.String) +System.UriBuilder.#ctor(System.String,System.String,System.Int32) +System.UriBuilder.#ctor(System.String,System.String,System.Int32,System.String) +System.UriBuilder.#ctor(System.String,System.String,System.Int32,System.String,System.String) +System.UriBuilder.#ctor(System.Uri) +System.UriBuilder.Equals(System.Object) +System.UriBuilder.GetHashCode +System.UriBuilder.ToString +System.UriBuilder.get_Fragment +System.UriBuilder.get_Host +System.UriBuilder.get_Password +System.UriBuilder.get_Path +System.UriBuilder.get_Port +System.UriBuilder.get_Query +System.UriBuilder.get_Scheme +System.UriBuilder.get_Uri +System.UriBuilder.get_UserName +System.UriBuilder.set_Fragment(System.String) +System.UriBuilder.set_Host(System.String) +System.UriBuilder.set_Password(System.String) +System.UriBuilder.set_Path(System.String) +System.UriBuilder.set_Port(System.Int32) +System.UriBuilder.set_Query(System.String) +System.UriBuilder.set_Scheme(System.String) +System.UriBuilder.set_UserName(System.String) +System.UriComponents +System.UriComponents.AbsoluteUri +System.UriComponents.Fragment +System.UriComponents.Host +System.UriComponents.HostAndPort +System.UriComponents.HttpRequestUrl +System.UriComponents.KeepDelimiter +System.UriComponents.NormalizedHost +System.UriComponents.Path +System.UriComponents.PathAndQuery +System.UriComponents.Port +System.UriComponents.Query +System.UriComponents.Scheme +System.UriComponents.SchemeAndServer +System.UriComponents.SerializationInfoString +System.UriComponents.StrongAuthority +System.UriComponents.StrongPort +System.UriComponents.UserInfo +System.UriCreationOptions +System.UriCreationOptions.get_DangerousDisablePathAndQueryCanonicalization +System.UriCreationOptions.set_DangerousDisablePathAndQueryCanonicalization(System.Boolean) +System.UriFormat +System.UriFormat.SafeUnescaped +System.UriFormat.Unescaped +System.UriFormat.UriEscaped +System.UriFormatException +System.UriFormatException.#ctor +System.UriFormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.UriFormatException.#ctor(System.String) +System.UriFormatException.#ctor(System.String,System.Exception) +System.UriHostNameType +System.UriHostNameType.Basic +System.UriHostNameType.Dns +System.UriHostNameType.IPv4 +System.UriHostNameType.IPv6 +System.UriHostNameType.Unknown +System.UriKind +System.UriKind.Absolute +System.UriKind.Relative +System.UriKind.RelativeOrAbsolute +System.UriParser +System.UriParser.#ctor +System.UriParser.GetComponents(System.Uri,System.UriComponents,System.UriFormat) +System.UriParser.InitializeAndValidate(System.Uri,System.UriFormatException@) +System.UriParser.IsBaseOf(System.Uri,System.Uri) +System.UriParser.IsKnownScheme(System.String) +System.UriParser.IsWellFormedOriginalString(System.Uri) +System.UriParser.OnNewUri +System.UriParser.OnRegister(System.String,System.Int32) +System.UriParser.Register(System.UriParser,System.String,System.Int32) +System.UriParser.Resolve(System.Uri,System.Uri,System.UriFormatException@) +System.UriPartial +System.UriPartial.Authority +System.UriPartial.Path +System.UriPartial.Query +System.UriPartial.Scheme +System.ValueTuple +System.ValueTuple.CompareTo(System.ValueTuple) +System.ValueTuple.Create +System.ValueTuple.Create``1(``0) +System.ValueTuple.Create``2(``0,``1) +System.ValueTuple.Create``3(``0,``1,``2) +System.ValueTuple.Create``4(``0,``1,``2,``3) +System.ValueTuple.Create``5(``0,``1,``2,``3,``4) +System.ValueTuple.Create``6(``0,``1,``2,``3,``4,``5) +System.ValueTuple.Create``7(``0,``1,``2,``3,``4,``5,``6) +System.ValueTuple.Create``8(``0,``1,``2,``3,``4,``5,``6,``7) +System.ValueTuple.Equals(System.Object) +System.ValueTuple.Equals(System.ValueTuple) +System.ValueTuple.GetHashCode +System.ValueTuple.ToString +System.ValueTuple`1 +System.ValueTuple`1.#ctor(`0) +System.ValueTuple`1.CompareTo(System.ValueTuple{`0}) +System.ValueTuple`1.Equals(System.Object) +System.ValueTuple`1.Equals(System.ValueTuple{`0}) +System.ValueTuple`1.GetHashCode +System.ValueTuple`1.Item1 +System.ValueTuple`1.ToString +System.ValueTuple`2 +System.ValueTuple`2.#ctor(`0,`1) +System.ValueTuple`2.CompareTo(System.ValueTuple{`0,`1}) +System.ValueTuple`2.Equals(System.Object) +System.ValueTuple`2.Equals(System.ValueTuple{`0,`1}) +System.ValueTuple`2.GetHashCode +System.ValueTuple`2.Item1 +System.ValueTuple`2.Item2 +System.ValueTuple`2.ToString +System.ValueTuple`3 +System.ValueTuple`3.#ctor(`0,`1,`2) +System.ValueTuple`3.CompareTo(System.ValueTuple{`0,`1,`2}) +System.ValueTuple`3.Equals(System.Object) +System.ValueTuple`3.Equals(System.ValueTuple{`0,`1,`2}) +System.ValueTuple`3.GetHashCode +System.ValueTuple`3.Item1 +System.ValueTuple`3.Item2 +System.ValueTuple`3.Item3 +System.ValueTuple`3.ToString +System.ValueTuple`4 +System.ValueTuple`4.#ctor(`0,`1,`2,`3) +System.ValueTuple`4.CompareTo(System.ValueTuple{`0,`1,`2,`3}) +System.ValueTuple`4.Equals(System.Object) +System.ValueTuple`4.Equals(System.ValueTuple{`0,`1,`2,`3}) +System.ValueTuple`4.GetHashCode +System.ValueTuple`4.Item1 +System.ValueTuple`4.Item2 +System.ValueTuple`4.Item3 +System.ValueTuple`4.Item4 +System.ValueTuple`4.ToString +System.ValueTuple`5 +System.ValueTuple`5.#ctor(`0,`1,`2,`3,`4) +System.ValueTuple`5.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4}) +System.ValueTuple`5.Equals(System.Object) +System.ValueTuple`5.Equals(System.ValueTuple{`0,`1,`2,`3,`4}) +System.ValueTuple`5.GetHashCode +System.ValueTuple`5.Item1 +System.ValueTuple`5.Item2 +System.ValueTuple`5.Item3 +System.ValueTuple`5.Item4 +System.ValueTuple`5.Item5 +System.ValueTuple`5.ToString +System.ValueTuple`6 +System.ValueTuple`6.#ctor(`0,`1,`2,`3,`4,`5) +System.ValueTuple`6.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5}) +System.ValueTuple`6.Equals(System.Object) +System.ValueTuple`6.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5}) +System.ValueTuple`6.GetHashCode +System.ValueTuple`6.Item1 +System.ValueTuple`6.Item2 +System.ValueTuple`6.Item3 +System.ValueTuple`6.Item4 +System.ValueTuple`6.Item5 +System.ValueTuple`6.Item6 +System.ValueTuple`6.ToString +System.ValueTuple`7 +System.ValueTuple`7.#ctor(`0,`1,`2,`3,`4,`5,`6) +System.ValueTuple`7.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6}) +System.ValueTuple`7.Equals(System.Object) +System.ValueTuple`7.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6}) +System.ValueTuple`7.GetHashCode +System.ValueTuple`7.Item1 +System.ValueTuple`7.Item2 +System.ValueTuple`7.Item3 +System.ValueTuple`7.Item4 +System.ValueTuple`7.Item5 +System.ValueTuple`7.Item6 +System.ValueTuple`7.Item7 +System.ValueTuple`7.ToString +System.ValueTuple`8 +System.ValueTuple`8.#ctor(`0,`1,`2,`3,`4,`5,`6,`7) +System.ValueTuple`8.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6,`7}) +System.ValueTuple`8.Equals(System.Object) +System.ValueTuple`8.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6,`7}) +System.ValueTuple`8.GetHashCode +System.ValueTuple`8.Item1 +System.ValueTuple`8.Item2 +System.ValueTuple`8.Item3 +System.ValueTuple`8.Item4 +System.ValueTuple`8.Item5 +System.ValueTuple`8.Item6 +System.ValueTuple`8.Item7 +System.ValueTuple`8.Rest +System.ValueTuple`8.ToString +System.ValueType +System.ValueType.#ctor +System.ValueType.Equals(System.Object) +System.ValueType.GetHashCode +System.ValueType.ToString +System.Version +System.Version.#ctor +System.Version.#ctor(System.Int32,System.Int32) +System.Version.#ctor(System.Int32,System.Int32,System.Int32) +System.Version.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) +System.Version.#ctor(System.String) +System.Version.Clone +System.Version.CompareTo(System.Object) +System.Version.CompareTo(System.Version) +System.Version.Equals(System.Object) +System.Version.Equals(System.Version) +System.Version.GetHashCode +System.Version.Parse(System.ReadOnlySpan{System.Char}) +System.Version.Parse(System.String) +System.Version.ToString +System.Version.ToString(System.Int32) +System.Version.TryFormat(System.Span{System.Byte},System.Int32,System.Int32@) +System.Version.TryFormat(System.Span{System.Byte},System.Int32@) +System.Version.TryFormat(System.Span{System.Char},System.Int32,System.Int32@) +System.Version.TryFormat(System.Span{System.Char},System.Int32@) +System.Version.TryParse(System.ReadOnlySpan{System.Char},System.Version@) +System.Version.TryParse(System.String,System.Version@) +System.Version.get_Build +System.Version.get_Major +System.Version.get_MajorRevision +System.Version.get_Minor +System.Version.get_MinorRevision +System.Version.get_Revision +System.Version.op_Equality(System.Version,System.Version) +System.Version.op_GreaterThan(System.Version,System.Version) +System.Version.op_GreaterThanOrEqual(System.Version,System.Version) +System.Version.op_Inequality(System.Version,System.Version) +System.Version.op_LessThan(System.Version,System.Version) +System.Version.op_LessThanOrEqual(System.Version,System.Version) +System.Void +System.WeakReference +System.WeakReference.#ctor(System.Object) +System.WeakReference.#ctor(System.Object,System.Boolean) +System.WeakReference.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.WeakReference.Finalize +System.WeakReference.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.WeakReference.get_IsAlive +System.WeakReference.get_Target +System.WeakReference.get_TrackResurrection +System.WeakReference.set_Target(System.Object) +System.WeakReference`1 +System.WeakReference`1.#ctor(`0) +System.WeakReference`1.#ctor(`0,System.Boolean) +System.WeakReference`1.Finalize +System.WeakReference`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +System.WeakReference`1.SetTarget(`0) +System.WeakReference`1.TryGetTarget(`0@) \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt new file mode 100644 index 0000000000000..c8a0bee214e00 --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt @@ -0,0 +1,6243 @@ +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp1 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp10 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp11 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp2 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp3 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp4 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp5 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp6 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_1 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_2 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_3 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp8 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp9 +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.Default +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.LatestMajor +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.Preview +F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.value__ +F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.Parameter +F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.ParameterReference +F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameter +F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameterReference +F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.value__ +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AbstractKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AccessorList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAccessorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddressOfExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AliasKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AliasQualifiedName +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AllowsConstraintClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AllowsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandAmpersandToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnnotationsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousMethodExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousObjectCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousObjectMemberDeclarator +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgListExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgListKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Argument +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgumentList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayInitializerExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayRankSpecifier +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrowExpressionClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AscendingKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AscendingOrdering +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AssemblyKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsteriskEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsteriskToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsyncKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Attribute +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeArgument +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeArgumentList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeTargetSpecifier +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AwaitExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AwaitKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BackslashToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BadDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BadToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarBarToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseConstructorInitializer +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseAndExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseNotExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseOrExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Block +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BoolKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BracketedArgumentList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BracketedParameterList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BreakKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BreakStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ByKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ByteKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaretEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaretToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaseKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CasePatternSwitchLabel +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaseSwitchLabel +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CastExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchFilterClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharacterLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharacterLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ChecksumKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassConstraint +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseBraceToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseBracketToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseParenToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CoalesceAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CoalesceExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CollectionExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CollectionInitializerExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ColonColonToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ColonToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CommaToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CompilationUnit +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ComplexElementInitializerExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConditionalAccessExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConditionalExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConflictMarkerTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstantPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstructorConstraint +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstructorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ContinueKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ContinueStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConversionOperatorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConversionOperatorMemberCref +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefBracketedParameterList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefParameter +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefParameterList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DecimalKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DeclarationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DeclarationPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultConstraint +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultSwitchLabel +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DelegateDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DelegateKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DescendingKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DescendingOrdering +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DestructorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DisabledTextTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DisableKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DiscardDesignation +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DiscardPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DocumentationCommentExteriorTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DollarToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DotDotToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DotToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoubleKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoubleQuoteToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElementAccessExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElementBindingExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElifDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElifKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EmptyStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnableKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndIfDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndIfKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfDirectiveToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfDocumentationCommentToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfFileToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfLineTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndRegionDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndRegionKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumMemberDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsGreaterThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsValueClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ErrorDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ErrorKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventFieldDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclusiveOrAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclusiveOrExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExplicitInterfaceSpecifier +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExplicitKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionColon +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionElement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExternAliasDirective +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExternKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FalseKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FalseLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileScopedNamespaceDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FinallyClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FinallyKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FixedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FixedStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FloatKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachVariableStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FromClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FromKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerCallingConvention +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameter +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameterList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConvention +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConventionList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GenericName +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetAccessorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GlobalKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GlobalStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoCaseStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoDefaultStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanGreaterThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanOrEqualExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GroupClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GroupKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.HashToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.HiddenKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierName +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitArrayCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitElementAccess +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitObjectCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitStackAllocArrayCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IncompleteMember +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexerDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexerMemberCref +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InitAccessorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InitKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedMultiLineRawStringStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedRawStringEndToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedSingleLineRawStringStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringEndToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringText +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringTextToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedVerbatimStringStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Interpolation +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolationAlignmentClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolationFormatClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IntKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IntoKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InvocationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsPatternExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinIntoClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LabeledStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LeftShiftAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LeftShiftExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanLessThanEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanLessThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanOrEqualExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanSlashToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LetClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LetKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectivePosition +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineSpanDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.List +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ListPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LoadDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LoadKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LocalDeclarationStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LocalFunctionStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LockKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LockStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalAndExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalNotExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalOrExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LongKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MakeRefExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MakeRefKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ManagedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MemberBindingExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MethodDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MethodKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusGreaterThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusMinusToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuleKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuloAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuloExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineCommentTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineDocumentationCommentTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineRawStringLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameColon +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameEquals +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameMemberCref +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameOfKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NamespaceDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NamespaceKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NewKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.None +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotEqualsExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectInitializerExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedArraySizeExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedArraySizeExpressionToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedTypeArgument +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedTypeArgumentToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OnKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenBraceToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenBracketToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenParenToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorMemberCref +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrderByClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrderByKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OutKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OverrideKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Parameter +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParameterList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParamKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParamsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedLambdaExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedVariableDesignation +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PartialKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PercentEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PercentToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusPlusToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerIndirectionExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerMemberAccessExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PositionalPatternClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostDecrementExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostIncrementExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaChecksumDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaWarningDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreDecrementExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PredefinedType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreIncrementExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreprocessingMessageTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrimaryConstructorBaseType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrivateKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyPatternClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PublicKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QualifiedCref +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QualifiedName +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryBody +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryContinuation +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionQuestionEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionQuestionToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RangeExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RazorContentToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReadOnlyKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordStructDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecursivePattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReferenceDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReferenceKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefStructConstraint +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefTypeExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefTypeKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefValueExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefValueKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RegionDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RegionKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RelationalPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveAccessorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RequiredKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RestoreKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReturnKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReturnStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RightShiftAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RightShiftExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SByteKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ScopedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ScopedType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SealedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SelectClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SelectKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SemicolonToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetAccessorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ShebangDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ShortKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleBaseType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleLambdaExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleMemberAccessExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineCommentTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineDocumentationCommentTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineRawStringLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleQuoteToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleVariableDesignation +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SizeOfExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SizeOfKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SkippedTokensTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashEqualsToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashGreaterThanToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlicePattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SpreadElement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StackAllocArrayCreationExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StackAllocKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StaticKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructConstraint +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Subpattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SuppressNullableWarningExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchExpressionArm +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchSection +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisConstructorInitializer +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TildeToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TrueKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TrueLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TryKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TryStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleElement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleType +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeArgumentList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeConstraint +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeCref +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeOfExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeOfKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameter +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameterConstraintClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameterList +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypePattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeVarKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UIntKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ULongKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryMinusExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryPlusExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UndefDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UndefKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnderscoreToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnknownAccessorDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnmanagedKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsafeKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsafeStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsignedRightShiftAssignmentExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsignedRightShiftExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UShortKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingDirective +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8MultiLineRawStringLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8SingleLineRawStringLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8StringLiteralExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8StringLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.value__ +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VariableDeclaration +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VariableDeclarator +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VarKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VarPattern +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VirtualKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VoidKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VolatileKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningDirectiveTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningsKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhenClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhenKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhereClause +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhereKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhileKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhileStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhitespaceTrivia +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithInitializerExpression +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataEndToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataSection +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlComment +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCommentEndToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCommentStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCrefAttribute +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElementEndTag +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElementStartTag +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlEmptyElement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlEntityLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlName +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlNameAttribute +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlPrefix +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstruction +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstructionEndToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstructionStartToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlText +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextAttribute +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextLiteralNewLineToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextLiteralToken +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldBreakStatement +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldKeyword +F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldReturnStatement +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo) +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_GetAwaiterMethod +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_GetResultMethod +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_IsCompletedProperty +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_IsDynamic +M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetHashCode +M:Microsoft.CodeAnalysis.CSharp.Conversion.Equals(Microsoft.CodeAnalysis.CSharp.Conversion) +M:Microsoft.CodeAnalysis.CSharp.Conversion.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_ConstrainedToType +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_Exists +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsAnonymousFunction +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsBoxing +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsCollectionExpression +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsConditionalExpression +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsConstantExpression +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsDefaultLiteral +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsDynamic +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsEnumeration +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsExplicit +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsIdentity +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsImplicit +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInlineArray +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInterpolatedString +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInterpolatedStringHandler +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsIntPtr +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsMethodGroup +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNullable +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNullLiteral +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNumeric +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsObjectCreation +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsPointer +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsReference +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsStackAlloc +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsSwitchExpression +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsThrow +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsTupleConversion +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsTupleLiteralConversion +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsUnboxing +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsUserDefined +M:Microsoft.CodeAnalysis.CSharp.Conversion.get_MethodSymbol +M:Microsoft.CodeAnalysis.CSharp.Conversion.GetHashCode +M:Microsoft.CodeAnalysis.CSharp.Conversion.op_Equality(Microsoft.CodeAnalysis.CSharp.Conversion,Microsoft.CodeAnalysis.CSharp.Conversion) +M:Microsoft.CodeAnalysis.CSharp.Conversion.op_Inequality(Microsoft.CodeAnalysis.CSharp.Conversion,Microsoft.CodeAnalysis.CSharp.Conversion) +M:Microsoft.CodeAnalysis.CSharp.Conversion.ToCommonConversion +M:Microsoft.CodeAnalysis.CSharp.Conversion.ToString +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_CompilationOptions +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_CompilationOptionsCore +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_ParseOptions +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_ParseOptionsCore +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_Default +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_RegularFileExtension +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_Script +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_ScriptFileExtension +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Parse(System.Collections.Generic.IEnumerable{System.String},System.String,System.String,System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ParseConditionalCompilationSymbols(System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Diagnostic}@) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AppendDefaultVersionResource(System.IO.Stream) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Clone +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonAddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonClone +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateNativeIntegerTypeSymbol(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetEntryPoint(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetTypeByMetadataName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonRemoveAllSyntaxTrees +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonRemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithAssemblyName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithOptions(Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference},Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CreateScriptCompilation(System.String,Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference},Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions,Microsoft.CodeAnalysis.CSharp.CSharpCompilation,System.Type,System.Type) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonAssembly +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonDynamicType +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonGlobalNamespace +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonObjectType +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonOptions +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonScriptClass +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonScriptGlobalsType +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonSourceModule +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonSyntaxTrees +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_DirectiveReferences +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_IsCaseSensitive +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_Language +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_LanguageVersion +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_Options +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_ReferencedAssemblyNames +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_ScriptCompilationInfo +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_SyntaxTrees +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDeclarationDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDirectiveReference(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetParseDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetUsedAssemblyReferences(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllReferences +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllSyntaxTrees +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(Microsoft.CodeAnalysis.MetadataReference[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.MetadataReference) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithAssemblyName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithOptions(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(Microsoft.CodeAnalysis.MetadataReference[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider,System.Boolean,Microsoft.CodeAnalysis.MetadataImportOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider,System.Boolean,Microsoft.CodeAnalysis.MetadataImportOptions,Microsoft.CodeAnalysis.NullableContextOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCheckOverflow(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithConcurrentBuild(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoKeyContainer(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoKeyFile(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithDelaySign(System.Nullable{System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithDeterministic(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithFeatures(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMainTypeName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithModuleName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithOutputKind(Microsoft.CodeAnalysis.OutputKind) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithPlatform(Microsoft.CodeAnalysis.Platform) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithPublicSign(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithReportSuppressedDiagnostics(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithScriptClassName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.ComputeHashCode +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_AllowUnsafe +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_Language +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_NullableContextOptions +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_Usings +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.set_NullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAllowUnsafe(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithConcurrentBuild(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyContainer(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyFile(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDelaySign(System.Nullable{System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterministic(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMainTypeName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithModuleName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithNullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOverflowChecks(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPublicSign(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithReportSuppressedDiagnostics(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithScriptClassName(System.String) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.String[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithWarningLevel(System.Int32) +M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +M:Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter.get_Instance +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAliasInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAwaitExpressionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCollectionInitializerSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCompilationUnitRoot(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConstantValue(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetElementConversion(Microsoft.CodeAnalysis.Operations.ISpreadOperation) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetFirstDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInConversion(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetIndexerGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptableLocation(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptorMethod(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptsLocationAttributeSyntax(Microsoft.CodeAnalysis.CSharp.InterceptableLocation) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetLastDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetOutConversion(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetQueryClauseInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeAliasInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeConversion(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeTypeInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Insert(Microsoft.CodeAnalysis.SyntaxTokenList,System.Int32,Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsContextualKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsReservedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimStringLiteral(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SemanticModel@,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel@) +M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.VarianceKindFromToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions.Emit(Microsoft.CodeAnalysis.CSharp.CSharpCompilation,System.String,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(Microsoft.CodeAnalysis.IIncrementalGenerator[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(Microsoft.CodeAnalysis.ISourceGenerator[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ISourceGenerator},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) +M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ISourceGenerator},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider,Microsoft.CodeAnalysis.GeneratorDriverOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.#ctor(Microsoft.CodeAnalysis.CSharp.LanguageVersion,Microsoft.CodeAnalysis.DocumentationMode,Microsoft.CodeAnalysis.SourceCodeKind,System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Default +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Features +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Language +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_LanguageVersion +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_PreprocessorSymbolNames +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_SpecifiedLanguageVersion +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.GetHashCode +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.String[]) +M:Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.get_PreviousScriptCompilation +M:Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.CSharp.CSharpCompilation) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.DeserializeFrom(System.IO.Stream,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.EquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindToken(System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.get_Language +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.get_SyntaxTreeCore +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetDiagnostics +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLeadingTrivia +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLocation +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetTrailingTrivia +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertNodesInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertTokensInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.IsEquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Kind +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.NormalizeWhitespaceCore(System.String,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.RemoveNodesCore(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceCore``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceNodeInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceTokenInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.#ctor(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.get_VisitIntoStructuredTrivia +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.Visit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList``1(Microsoft.CodeAnalysis.SyntaxList{``0}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement``1(``0) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListSeparator(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.#ctor +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CloneNodeAsRoot``1(``0) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.get_Options +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.get_OptionsCore +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetCompilationUnitRoot(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineMappings(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineVisibility(System.Int32,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRoot(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootCore(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.HasHiddenRegions +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRoot(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode@) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRootCore(Microsoft.CodeAnalysis.SyntaxNode@) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.#ctor +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.Visit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.#ctor +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.Visit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.#ctor(Microsoft.CodeAnalysis.SyntaxWalkerDepth) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.get_Depth +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitLeadingTrivia(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrailingTrivia(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Conversion +M:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Method +M:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Nested +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo) +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_CurrentConversion +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_CurrentProperty +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_DisposeMethod +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_ElementConversion +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_ElementType +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_GetEnumeratorMethod +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_IsAsynchronous +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_MoveNextMethod +M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.GetHashCode +M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.get_Data +M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.get_Version +M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetDisplayLocation +M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetHashCode +M:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.MapSpecifiedToEffectiveVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion) +M:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.ToDisplayString(Microsoft.CodeAnalysis.CSharp.LanguageVersion) +M:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.TryParse(System.String,Microsoft.CodeAnalysis.CSharp.LanguageVersion@) +M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(Microsoft.CodeAnalysis.CSharp.QueryClauseInfo) +M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.get_CastInfo +M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.get_OperationInfo +M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.GetHashCode +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(System.Char,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatPrimitive(System.Object,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.AddAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_Accessors +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithAccessors(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_Alias +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_ColonColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithColonColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.AddConstraints(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.get_AllowsKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.get_Constraints +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.WithAllowsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_AsyncKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_AsyncKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_DelegateKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.AddInitializers(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_Initializers +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.get_NameEquals +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_Arguments +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_NameColon +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_RefKindKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_RefOrOutKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.AddTypeRankSpecifiers(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.AddSizes(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_Rank +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_Sizes +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithSizes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.AddRankSpecifiers(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.get_ElementType +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.get_RankSpecifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithRankSpecifiers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.get_ArrowToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_Left +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_Right +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_Arguments +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_NameColon +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_NameEquals +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_Attributes +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_Target +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithAttributes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithTarget(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.get_AwaitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.get_Arguments +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.get_Token +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.AddTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.get_Types +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithTypes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Externs +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_NamespaceKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Usings +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_AccessorList +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_BaseList +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_Left +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_Right +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_Left +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_Right +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_Statements +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_Arguments +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.get_BranchTaken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_BreakKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_WhenClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_Value +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_CatchKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Filter +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithCatchKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithFilter(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_FilterExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_WhenKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithFilterExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_BaseList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.get_ClassOrStructKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.get_QuestionToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.AddElements(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_Elements +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_AwaitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_ForEachKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_InKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_EndOfFileToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Externs +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Usings +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetLoadDirectives +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetReferenceDirectives +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithEndOfFileToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_WhenNotNull +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithWhenNotNull(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.get_ConditionValue +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_QuestionToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_WhenFalse +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_WhenTrue +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenFalse(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenTrue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ThisOrBaseKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithThisOrBaseKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_ContinueKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithContinueKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_CheckedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ImplicitOrExplicitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_OperatorKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_CheckedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_ImplicitOrExplicitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_OperatorKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_ReadOnlyKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_RefKindKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_RefOrOutKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.get_Designation +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.get_Designation +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.get_DefaultKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.WithDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_DefineKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithDefineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Arity +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_DelegateKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ReturnType +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_TildeToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithTildeToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_DirectiveNameToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetNextDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetPreviousDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetRelatedDirectives +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.get_UnderscoreToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.get_UnderscoreToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.AddContent(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.get_Content +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.get_EndOfComment +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithEndOfComment(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_DoKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_WhileKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithDoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_BranchTaken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_ConditionValue +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_ElifKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithConditionValue(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithElifKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.get_ElseKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_BranchTaken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_ElseKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_EndIfKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_EndRegionKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_BaseList +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_EnumKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithEnumKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_EqualsValue +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithEqualsValue(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.get_Value +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_ErrorKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithErrorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_AccessorList +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_EventKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_EventKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.get_DotToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_AllowsAnyExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_AliasKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_ExternKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithAliasKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithExternKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Externs +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_NamespaceKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Usings +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.get_FinallyKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithFinallyKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_FixedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithFixedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_AwaitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_ForEachKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_InKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_AwaitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_ForEachKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_InKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Variable +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithVariable(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddIncrementors(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddInitializers(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_FirstSemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_ForKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Incrementors +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Initializers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_SecondSemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithFirstSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithForKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithIncrementors(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithSecondSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_FromKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_InKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithFromKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.get_ManagedOrUnmanagedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.get_UnmanagedCallingConventionList +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedOrUnmanagedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_GreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_LessThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_AsteriskToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_CallingConvention +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_DelegateKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.AddCallingConventions(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_CallingConventions +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.AddTypeArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_IsUnboundGenericName +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_TypeArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_CaseOrDefaultKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_GotoKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithCaseOrDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithGotoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_ByExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_ByKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_GroupExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_GroupKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_BranchTaken +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_ConditionValue +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_IfKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithConditionValue(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Else +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_IfKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithElse(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddCommas(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_Commas +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCommas(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_StackAllocKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_AccessorList +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Semicolon +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ThisKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.get_ThisKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.AddExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_Expressions +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithExpressions(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_BaseList +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.AddContents(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_Contents +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_StringEndToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_StringStartToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithContents(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringEndToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringStartToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.get_TextToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.WithTextToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.get_CommaToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.get_Value +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.get_FormatStringToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithFormatStringToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_AlignmentClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_FormatClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_IsKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithIsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_EqualsKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_InExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_InKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Into +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_JoinKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_LeftExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_OnKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_RightExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithEqualsKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInto(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithJoinKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithLeftExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithOnKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithRightExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.get_IntoKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.get_ArrowToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_LetKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithLetKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_Character +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_CommaToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_Line +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCharacter(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_File +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_Line +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_LineKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.get_File +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.get_LineKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_CharacterOffset +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_End +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_File +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_LineKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_MinusToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_Start +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithCharacterOffset(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEnd(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithMinusToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithStart(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.AddPatterns(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_CloseBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_Designation +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_OpenBracketToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_Patterns +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithPatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.get_Token +M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_File +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_LoadKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithLoadKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_AwaitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_IsConst +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_UsingKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ReturnType +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_LockKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithLockKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Arity +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ReturnType +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Externs +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_NamespaceKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Usings +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax.get_Arity +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_NullableKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_SettingToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_TargetToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithNullableKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithSettingToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithTargetToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.get_ElementType +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.get_QuestionToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_NewKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.get_OmittedArraySizeExpressionToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.WithOmittedArraySizeExpressionToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.get_OmittedTypeArgumentToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.WithOmittedTypeArgumentToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_CheckedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_OperatorKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ReturnType +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_CheckedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_OperatorKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.AddOrderings(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.get_OrderByKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.get_Orderings +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderByKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderings(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.get_AscendingOrDescendingKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithAscendingOrDescendingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Default +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ArrowToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_AsyncKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ReturnType +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.AddVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_Variables +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.get_AsteriskToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.get_ElementType +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.AddSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_Subpatterns +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.get_Operand +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_Bytes +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_ChecksumKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_File +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_Guid +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_PragmaKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithBytes(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithChecksumKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithGuid(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.AddErrorCodes(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_DisableOrRestoreKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_ErrorCodes +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_PragmaKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_WarningKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithDisableOrRestoreKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithErrorCodes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.get_Operand +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_AccessorList +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_ExplicitInterfaceSpecifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Semicolon +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.AddSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_Subpatterns +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_Container +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_DotToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_Member +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithContainer(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithMember(Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_DotToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_Left +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_Right +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.AddClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_Clauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_Continuation +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_SelectOrGroup +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithSelectOrGroup(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.AddBodyClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_IntoKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.AddBodyClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.get_Body +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.get_FromClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_LeftOperand +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_RightOperand +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithLeftOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithRightOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_BaseList +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ClassOrStructKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPositionalPatternClauseSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPropertyPatternClauseSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_Designation +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_PositionalPatternClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_PropertyPatternClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_File +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_ReferenceKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithReferenceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.get_RefKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.get_RefKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.get_StructKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.WithStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_ReadOnlyKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_RefKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Comma +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithComma(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_RegionKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_ReturnKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithReturnKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.get_ScopedKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.WithScopedKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.get_SelectKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithSelectKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_ExclamationToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithExclamationToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_ArrowToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_AsyncKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_ExpressionBody +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Parameter +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.AddTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.get_Tokens +M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.WithTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.get_DotDotToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithDotDotToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_StackAllocKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_BaseList +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Modifiers +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax.get_ParentTrivia +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_ExpressionColon +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_NameColon +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_EqualsGreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_WhenClause +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithEqualsGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.AddArms(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_Arms +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_GoverningExpression +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_SwitchKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithArms(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithGoverningExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddLabels(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.get_Labels +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.get_Statements +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithLabels(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddSections(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_CloseBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_OpenBraceToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_Sections +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_SwitchKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSections(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.get_Token +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.get_ThrowKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_ThrowKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddCatches(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Catches +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Finally +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_TryKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithCatches(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithFinally(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithTryKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_Arguments +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.AddElements(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_Elements +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_Arguments +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_GreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_LessThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Arity +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_ConstraintClauses +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Members +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_ParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_TypeParameterList +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_Keyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.AddConstraints(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_Constraints +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_WhereKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_GreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_LessThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_Parameters +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_VarianceKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithVarianceKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNint +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNotNull +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNuint +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsUnmanaged +M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsVar +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.get_OperatorToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.get_Pattern +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_UndefKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithUndefKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_Block +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_UnsafeKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_Alias +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_GlobalKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_NamespaceOrType +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_StaticKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_UnsafeKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_UsingKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithGlobalKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithNamespaceOrType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithStaticKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_AwaitKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Declaration +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_UsingKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.AddVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.get_Type +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.get_Variables +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_ArgumentList +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.get_Designation +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.get_VarKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithVarKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_EndOfDirectiveToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_HashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_IsActive +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_WarningKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithIsActive(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.get_WhenKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.get_WhereKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_CloseParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_Condition +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_OpenParenToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_Statement +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_WhileKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_Initializer +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_WithKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithWithKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_EndQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_StartQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_EndCDataToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_StartCDataToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_TextTokens +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithEndCDataToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithStartCDataToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_LessThanExclamationMinusMinusToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_MinusMinusGreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_TextTokens +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithLessThanExclamationMinusMinusToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithMinusMinusGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_Cref +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_EndQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_StartQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_GreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_LessThanSlashToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithLessThanSlashToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_Attributes +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_GreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_LessThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddContent(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddStartTagAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_Content +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_EndTag +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_StartTag +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_Attributes +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_LessThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_SlashGreaterThanToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithSlashGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_EndQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_Identifier +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_StartQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.get_LocalName +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.get_Prefix +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithLocalName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.get_ColonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.get_Prefix +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithPrefix(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_EndProcessingInstructionToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_StartProcessingInstructionToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_TextTokens +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithEndProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithStartProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_EndQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_EqualsToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_Name +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_StartQuoteToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_TextTokens +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.get_TextTokens +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_AttributeLists +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_Expression +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_ReturnOrBreakKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_SemicolonToken +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_YieldKeyword +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithReturnOrBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithYieldKeyword(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxToken,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxToken,System.String,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.ToSyntaxTriviaList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AllowsConstraintClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AllowsConstraintClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.SyntaxList{``0},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.SyntaxList{``0},System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadToken(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CollectionExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CollectionExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Comment(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CreateTokenParser(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DisabledText(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentExterior(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticEndOfLine(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticWhitespace(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_CarriageReturn +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_CarriageReturnLineFeed +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticCarriageReturn +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticCarriageReturnLineFeed +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticLineFeed +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticMarker +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticSpace +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticTab +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_LineFeed +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_Space +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_Tab +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetNonGenericExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetStandaloneExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationAlignmentClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsCompleteSubmission(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List``1 +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List``1(System.Collections.Generic.IEnumerable{``0}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Char,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Decimal,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Double,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Int32,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Int64,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Single,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.UInt32,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.UInt64,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Char) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Decimal) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Double) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Int32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Int64) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Single) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Char) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Decimal) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Double) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Int32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Int64) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Single) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.UInt32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.UInt64) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.UInt32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.UInt64) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(Microsoft.CodeAnalysis.SyntaxNodeOrToken[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseAttributeArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedParameterList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseCompilationUnit(System.String,System.Int32,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseExpression(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseLeadingTrivia(System.String,System.Int32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseMemberDeclaration(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseName(System.String,System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseParameterList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseStatement(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseToken(System.String,System.Int32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTokens(System.String,System.Int32,System.Int32,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTrailingTrivia(System.String,System.Int32) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(System.String,System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PredefinedType(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PreprocessingMessage(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefStructConstraint +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefStructConstraint(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RelationalPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ScopedType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1 +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{``0}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonList``1(``0) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonSeparatedList``1(``0) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingleVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SpreadElement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Trivia(Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEntity(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.String,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNewLine(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNullKeywordElement +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamRefElement(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPreliminaryElement +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(System.Uri,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(System.String,System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement(System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.get_EqualityComparer +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAccessorDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBaseTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetCheckStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKind(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKinds +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKind(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKinds +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetOperatorKind(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKind(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKinds +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPunctuationKinds +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetReservedKeywordKinds +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetSwitchLabelKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.Accessibility) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessibilityModifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclarationKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAliasQualifier(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyOverloadableOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeName(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsCheckedOperator(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsFixedStatementExpression(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsGlobalMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierPartCharacter(System.Char) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierStartCharacter(System.Char) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIndexed(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInNamespaceOrTypeContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInTypeOnlyContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInvoked(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsKeywordKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLambdaBody(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLanguagePunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsName(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamedArgumentName(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceAliasQualifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNewLine(System.Char) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableBinaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableUnaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPostfixUnaryExpressionToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPredefinedType(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrefixUnaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorDirective(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorPunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuationOrKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsQueryContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedTupleElementName(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeParameterVarianceKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeSyntax(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsUnaryOperatorDeclarationToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsValidIdentifier(System.String) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsWhitespace(System.Char) +M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.TryGetInferredMemberName(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Dispose +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseLeadingTrivia +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseNextToken +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseTrailingTrivia +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ResetTo(Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result) +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result.get_ContextualKind +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result.get_Token +M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.SkipForwardTo(System.Int32) +M:Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions.ToCSharpString(Microsoft.CodeAnalysis.TypedConstant) +M:Microsoft.CodeAnalysis.CSharpExtensions.Any(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.Any(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.Any``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.Any``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.ContainsDirective(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.CSharp.SyntaxKind) +T:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo +T:Microsoft.CodeAnalysis.CSharp.Conversion +T:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments +T:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser +T:Microsoft.CodeAnalysis.CSharp.CSharpCompilation +T:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions +T:Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter +T:Microsoft.CodeAnalysis.CSharp.CSharpExtensions +T:Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions +T:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver +T:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions +T:Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo +T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode +T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter +T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree +T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor +T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1 +T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker +T:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo +T:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo +T:Microsoft.CodeAnalysis.CSharp.InterceptableLocation +T:Microsoft.CodeAnalysis.CSharp.LanguageVersion +T:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts +T:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo +T:Microsoft.CodeAnalysis.CSharp.SymbolDisplay +T:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InstanceExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax +T:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax +T:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions +T:Microsoft.CodeAnalysis.CSharp.SyntaxFactory +T:Microsoft.CodeAnalysis.CSharp.SyntaxFacts +T:Microsoft.CodeAnalysis.CSharp.SyntaxKind +T:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser +T:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result +T:Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions +T:Microsoft.CodeAnalysis.CSharpExtensions \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt new file mode 100644 index 0000000000000..4cf6b5e5b832f --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt @@ -0,0 +1,4333 @@ +F:Microsoft.CodeAnalysis.Accessibility.Friend +F:Microsoft.CodeAnalysis.Accessibility.Internal +F:Microsoft.CodeAnalysis.Accessibility.NotApplicable +F:Microsoft.CodeAnalysis.Accessibility.Private +F:Microsoft.CodeAnalysis.Accessibility.Protected +F:Microsoft.CodeAnalysis.Accessibility.ProtectedAndFriend +F:Microsoft.CodeAnalysis.Accessibility.ProtectedAndInternal +F:Microsoft.CodeAnalysis.Accessibility.ProtectedOrFriend +F:Microsoft.CodeAnalysis.Accessibility.ProtectedOrInternal +F:Microsoft.CodeAnalysis.Accessibility.Public +F:Microsoft.CodeAnalysis.Accessibility.value__ +F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.Equivalent +F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.EquivalentIgnoringVersion +F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.NotEquivalent +F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.value__ +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.ContentType +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Culture +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Name +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKey +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKeyOrToken +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKeyToken +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Retargetability +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Unknown +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.value__ +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Version +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionBuild +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionMajor +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionMinor +F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionRevision +F:Microsoft.CodeAnalysis.CandidateReason.Ambiguous +F:Microsoft.CodeAnalysis.CandidateReason.Inaccessible +F:Microsoft.CodeAnalysis.CandidateReason.LateBound +F:Microsoft.CodeAnalysis.CandidateReason.MemberGroup +F:Microsoft.CodeAnalysis.CandidateReason.None +F:Microsoft.CodeAnalysis.CandidateReason.NotAnAttributeType +F:Microsoft.CodeAnalysis.CandidateReason.NotAnEvent +F:Microsoft.CodeAnalysis.CandidateReason.NotATypeOrNamespace +F:Microsoft.CodeAnalysis.CandidateReason.NotAValue +F:Microsoft.CodeAnalysis.CandidateReason.NotAVariable +F:Microsoft.CodeAnalysis.CandidateReason.NotAWithEventsMember +F:Microsoft.CodeAnalysis.CandidateReason.NotCreatable +F:Microsoft.CodeAnalysis.CandidateReason.NotInvocable +F:Microsoft.CodeAnalysis.CandidateReason.NotReferencable +F:Microsoft.CodeAnalysis.CandidateReason.OverloadResolutionFailure +F:Microsoft.CodeAnalysis.CandidateReason.StaticInstanceMismatch +F:Microsoft.CodeAnalysis.CandidateReason.value__ +F:Microsoft.CodeAnalysis.CandidateReason.WrongArity +F:Microsoft.CodeAnalysis.Compilation._features +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.None +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesFramework +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesNewerCompiler +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer +F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.value__ +F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.Analyze +F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.None +F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.ReportDiagnostics +F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.value__ +F:Microsoft.CodeAnalysis.DiagnosticSeverity.Error +F:Microsoft.CodeAnalysis.DiagnosticSeverity.Hidden +F:Microsoft.CodeAnalysis.DiagnosticSeverity.Info +F:Microsoft.CodeAnalysis.DiagnosticSeverity.value__ +F:Microsoft.CodeAnalysis.DiagnosticSeverity.Warning +F:Microsoft.CodeAnalysis.DocumentationMode.Diagnose +F:Microsoft.CodeAnalysis.DocumentationMode.None +F:Microsoft.CodeAnalysis.DocumentationMode.Parse +F:Microsoft.CodeAnalysis.DocumentationMode.value__ +F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.Embedded +F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.Pdb +F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.PortablePdb +F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.value__ +F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.ModuleCancellation +F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.None +F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.StackOverflowProbing +F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.TestCoverage +F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.value__ +F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Delete +F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Insert +F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.None +F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Replace +F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Update +F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.value__ +F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Block +F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Entry +F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Exit +F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.value__ +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Error +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.None +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.ProgramTermination +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Regular +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Rethrow +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Return +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.StructuredExceptionHandling +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Throw +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.value__ +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.None +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.value__ +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.WhenFalse +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.WhenTrue +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Catch +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.ErroneousBody +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Filter +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.FilterAndHandler +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Finally +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.LocalLifetime +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Root +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.StaticLocalInitializer +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Try +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.TryAndCatch +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.TryAndFinally +F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.value__ +F:Microsoft.CodeAnalysis.GeneratedKind.MarkedGenerated +F:Microsoft.CodeAnalysis.GeneratedKind.NotGenerated +F:Microsoft.CodeAnalysis.GeneratedKind.Unknown +F:Microsoft.CodeAnalysis.GeneratedKind.value__ +F:Microsoft.CodeAnalysis.GeneratorDriverOptions.DisabledOutputs +F:Microsoft.CodeAnalysis.GeneratorDriverOptions.TrackIncrementalGeneratorSteps +F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Implementation +F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.None +F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.PostInit +F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Source +F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.value__ +F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Cached +F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Modified +F:Microsoft.CodeAnalysis.IncrementalStepRunReason.New +F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Removed +F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Unchanged +F:Microsoft.CodeAnalysis.IncrementalStepRunReason.value__ +F:Microsoft.CodeAnalysis.LanguageNames.CSharp +F:Microsoft.CodeAnalysis.LanguageNames.FSharp +F:Microsoft.CodeAnalysis.LanguageNames.VisualBasic +F:Microsoft.CodeAnalysis.LineVisibility.BeforeFirstLineDirective +F:Microsoft.CodeAnalysis.LineVisibility.Hidden +F:Microsoft.CodeAnalysis.LineVisibility.value__ +F:Microsoft.CodeAnalysis.LineVisibility.Visible +F:Microsoft.CodeAnalysis.LocationKind.ExternalFile +F:Microsoft.CodeAnalysis.LocationKind.MetadataFile +F:Microsoft.CodeAnalysis.LocationKind.None +F:Microsoft.CodeAnalysis.LocationKind.SourceFile +F:Microsoft.CodeAnalysis.LocationKind.value__ +F:Microsoft.CodeAnalysis.LocationKind.XmlFile +F:Microsoft.CodeAnalysis.MetadataImageKind.Assembly +F:Microsoft.CodeAnalysis.MetadataImageKind.Module +F:Microsoft.CodeAnalysis.MetadataImageKind.value__ +F:Microsoft.CodeAnalysis.MetadataImportOptions.All +F:Microsoft.CodeAnalysis.MetadataImportOptions.Internal +F:Microsoft.CodeAnalysis.MetadataImportOptions.Public +F:Microsoft.CodeAnalysis.MetadataImportOptions.value__ +F:Microsoft.CodeAnalysis.MethodKind.AnonymousFunction +F:Microsoft.CodeAnalysis.MethodKind.BuiltinOperator +F:Microsoft.CodeAnalysis.MethodKind.Constructor +F:Microsoft.CodeAnalysis.MethodKind.Conversion +F:Microsoft.CodeAnalysis.MethodKind.DeclareMethod +F:Microsoft.CodeAnalysis.MethodKind.DelegateInvoke +F:Microsoft.CodeAnalysis.MethodKind.Destructor +F:Microsoft.CodeAnalysis.MethodKind.EventAdd +F:Microsoft.CodeAnalysis.MethodKind.EventRaise +F:Microsoft.CodeAnalysis.MethodKind.EventRemove +F:Microsoft.CodeAnalysis.MethodKind.ExplicitInterfaceImplementation +F:Microsoft.CodeAnalysis.MethodKind.FunctionPointerSignature +F:Microsoft.CodeAnalysis.MethodKind.LambdaMethod +F:Microsoft.CodeAnalysis.MethodKind.LocalFunction +F:Microsoft.CodeAnalysis.MethodKind.Ordinary +F:Microsoft.CodeAnalysis.MethodKind.PropertyGet +F:Microsoft.CodeAnalysis.MethodKind.PropertySet +F:Microsoft.CodeAnalysis.MethodKind.ReducedExtension +F:Microsoft.CodeAnalysis.MethodKind.SharedConstructor +F:Microsoft.CodeAnalysis.MethodKind.StaticConstructor +F:Microsoft.CodeAnalysis.MethodKind.UserDefinedOperator +F:Microsoft.CodeAnalysis.MethodKind.value__ +F:Microsoft.CodeAnalysis.NamespaceKind.Assembly +F:Microsoft.CodeAnalysis.NamespaceKind.Compilation +F:Microsoft.CodeAnalysis.NamespaceKind.Module +F:Microsoft.CodeAnalysis.NamespaceKind.value__ +F:Microsoft.CodeAnalysis.NullableAnnotation.Annotated +F:Microsoft.CodeAnalysis.NullableAnnotation.None +F:Microsoft.CodeAnalysis.NullableAnnotation.NotAnnotated +F:Microsoft.CodeAnalysis.NullableAnnotation.value__ +F:Microsoft.CodeAnalysis.NullableContext.AnnotationsContextInherited +F:Microsoft.CodeAnalysis.NullableContext.AnnotationsEnabled +F:Microsoft.CodeAnalysis.NullableContext.ContextInherited +F:Microsoft.CodeAnalysis.NullableContext.Disabled +F:Microsoft.CodeAnalysis.NullableContext.Enabled +F:Microsoft.CodeAnalysis.NullableContext.value__ +F:Microsoft.CodeAnalysis.NullableContext.WarningsContextInherited +F:Microsoft.CodeAnalysis.NullableContext.WarningsEnabled +F:Microsoft.CodeAnalysis.NullableContextOptions.Annotations +F:Microsoft.CodeAnalysis.NullableContextOptions.Disable +F:Microsoft.CodeAnalysis.NullableContextOptions.Enable +F:Microsoft.CodeAnalysis.NullableContextOptions.value__ +F:Microsoft.CodeAnalysis.NullableContextOptions.Warnings +F:Microsoft.CodeAnalysis.NullableFlowState.MaybeNull +F:Microsoft.CodeAnalysis.NullableFlowState.None +F:Microsoft.CodeAnalysis.NullableFlowState.NotNull +F:Microsoft.CodeAnalysis.NullableFlowState.value__ +F:Microsoft.CodeAnalysis.OperationKind.AddressOf +F:Microsoft.CodeAnalysis.OperationKind.AnonymousFunction +F:Microsoft.CodeAnalysis.OperationKind.AnonymousObjectCreation +F:Microsoft.CodeAnalysis.OperationKind.Argument +F:Microsoft.CodeAnalysis.OperationKind.ArrayCreation +F:Microsoft.CodeAnalysis.OperationKind.ArrayElementReference +F:Microsoft.CodeAnalysis.OperationKind.ArrayInitializer +F:Microsoft.CodeAnalysis.OperationKind.Attribute +F:Microsoft.CodeAnalysis.OperationKind.Await +F:Microsoft.CodeAnalysis.OperationKind.Binary +F:Microsoft.CodeAnalysis.OperationKind.BinaryOperator +F:Microsoft.CodeAnalysis.OperationKind.BinaryPattern +F:Microsoft.CodeAnalysis.OperationKind.Block +F:Microsoft.CodeAnalysis.OperationKind.Branch +F:Microsoft.CodeAnalysis.OperationKind.CaseClause +F:Microsoft.CodeAnalysis.OperationKind.CatchClause +F:Microsoft.CodeAnalysis.OperationKind.CaughtException +F:Microsoft.CodeAnalysis.OperationKind.Coalesce +F:Microsoft.CodeAnalysis.OperationKind.CoalesceAssignment +F:Microsoft.CodeAnalysis.OperationKind.CollectionElementInitializer +F:Microsoft.CodeAnalysis.OperationKind.CollectionExpression +F:Microsoft.CodeAnalysis.OperationKind.CompoundAssignment +F:Microsoft.CodeAnalysis.OperationKind.Conditional +F:Microsoft.CodeAnalysis.OperationKind.ConditionalAccess +F:Microsoft.CodeAnalysis.OperationKind.ConditionalAccessInstance +F:Microsoft.CodeAnalysis.OperationKind.ConstantPattern +F:Microsoft.CodeAnalysis.OperationKind.ConstructorBody +F:Microsoft.CodeAnalysis.OperationKind.ConstructorBodyOperation +F:Microsoft.CodeAnalysis.OperationKind.Conversion +F:Microsoft.CodeAnalysis.OperationKind.DeclarationExpression +F:Microsoft.CodeAnalysis.OperationKind.DeclarationPattern +F:Microsoft.CodeAnalysis.OperationKind.DeconstructionAssignment +F:Microsoft.CodeAnalysis.OperationKind.Decrement +F:Microsoft.CodeAnalysis.OperationKind.DefaultValue +F:Microsoft.CodeAnalysis.OperationKind.DelegateCreation +F:Microsoft.CodeAnalysis.OperationKind.Discard +F:Microsoft.CodeAnalysis.OperationKind.DiscardPattern +F:Microsoft.CodeAnalysis.OperationKind.DynamicIndexerAccess +F:Microsoft.CodeAnalysis.OperationKind.DynamicInvocation +F:Microsoft.CodeAnalysis.OperationKind.DynamicMemberReference +F:Microsoft.CodeAnalysis.OperationKind.DynamicObjectCreation +F:Microsoft.CodeAnalysis.OperationKind.Empty +F:Microsoft.CodeAnalysis.OperationKind.End +F:Microsoft.CodeAnalysis.OperationKind.EventAssignment +F:Microsoft.CodeAnalysis.OperationKind.EventReference +F:Microsoft.CodeAnalysis.OperationKind.ExpressionStatement +F:Microsoft.CodeAnalysis.OperationKind.FieldInitializer +F:Microsoft.CodeAnalysis.OperationKind.FieldReference +F:Microsoft.CodeAnalysis.OperationKind.FlowAnonymousFunction +F:Microsoft.CodeAnalysis.OperationKind.FlowCapture +F:Microsoft.CodeAnalysis.OperationKind.FlowCaptureReference +F:Microsoft.CodeAnalysis.OperationKind.FunctionPointerInvocation +F:Microsoft.CodeAnalysis.OperationKind.ImplicitIndexerReference +F:Microsoft.CodeAnalysis.OperationKind.Increment +F:Microsoft.CodeAnalysis.OperationKind.InlineArrayAccess +F:Microsoft.CodeAnalysis.OperationKind.InstanceReference +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedString +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAddition +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendFormatted +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendInvalid +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendLiteral +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringHandlerArgumentPlaceholder +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringHandlerCreation +F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringText +F:Microsoft.CodeAnalysis.OperationKind.Interpolation +F:Microsoft.CodeAnalysis.OperationKind.Invalid +F:Microsoft.CodeAnalysis.OperationKind.Invocation +F:Microsoft.CodeAnalysis.OperationKind.IsNull +F:Microsoft.CodeAnalysis.OperationKind.IsPattern +F:Microsoft.CodeAnalysis.OperationKind.IsType +F:Microsoft.CodeAnalysis.OperationKind.Labeled +F:Microsoft.CodeAnalysis.OperationKind.ListPattern +F:Microsoft.CodeAnalysis.OperationKind.Literal +F:Microsoft.CodeAnalysis.OperationKind.LocalFunction +F:Microsoft.CodeAnalysis.OperationKind.LocalReference +F:Microsoft.CodeAnalysis.OperationKind.Lock +F:Microsoft.CodeAnalysis.OperationKind.Loop +F:Microsoft.CodeAnalysis.OperationKind.MemberInitializer +F:Microsoft.CodeAnalysis.OperationKind.MethodBody +F:Microsoft.CodeAnalysis.OperationKind.MethodBodyOperation +F:Microsoft.CodeAnalysis.OperationKind.MethodReference +F:Microsoft.CodeAnalysis.OperationKind.NameOf +F:Microsoft.CodeAnalysis.OperationKind.NegatedPattern +F:Microsoft.CodeAnalysis.OperationKind.None +F:Microsoft.CodeAnalysis.OperationKind.ObjectCreation +F:Microsoft.CodeAnalysis.OperationKind.ObjectOrCollectionInitializer +F:Microsoft.CodeAnalysis.OperationKind.OmittedArgument +F:Microsoft.CodeAnalysis.OperationKind.ParameterInitializer +F:Microsoft.CodeAnalysis.OperationKind.ParameterReference +F:Microsoft.CodeAnalysis.OperationKind.Parenthesized +F:Microsoft.CodeAnalysis.OperationKind.PropertyInitializer +F:Microsoft.CodeAnalysis.OperationKind.PropertyReference +F:Microsoft.CodeAnalysis.OperationKind.PropertySubpattern +F:Microsoft.CodeAnalysis.OperationKind.RaiseEvent +F:Microsoft.CodeAnalysis.OperationKind.Range +F:Microsoft.CodeAnalysis.OperationKind.RecursivePattern +F:Microsoft.CodeAnalysis.OperationKind.ReDim +F:Microsoft.CodeAnalysis.OperationKind.ReDimClause +F:Microsoft.CodeAnalysis.OperationKind.RelationalPattern +F:Microsoft.CodeAnalysis.OperationKind.Return +F:Microsoft.CodeAnalysis.OperationKind.SimpleAssignment +F:Microsoft.CodeAnalysis.OperationKind.SizeOf +F:Microsoft.CodeAnalysis.OperationKind.SlicePattern +F:Microsoft.CodeAnalysis.OperationKind.Spread +F:Microsoft.CodeAnalysis.OperationKind.StaticLocalInitializationSemaphore +F:Microsoft.CodeAnalysis.OperationKind.Stop +F:Microsoft.CodeAnalysis.OperationKind.Switch +F:Microsoft.CodeAnalysis.OperationKind.SwitchCase +F:Microsoft.CodeAnalysis.OperationKind.SwitchExpression +F:Microsoft.CodeAnalysis.OperationKind.SwitchExpressionArm +F:Microsoft.CodeAnalysis.OperationKind.Throw +F:Microsoft.CodeAnalysis.OperationKind.TranslatedQuery +F:Microsoft.CodeAnalysis.OperationKind.Try +F:Microsoft.CodeAnalysis.OperationKind.Tuple +F:Microsoft.CodeAnalysis.OperationKind.TupleBinary +F:Microsoft.CodeAnalysis.OperationKind.TupleBinaryOperator +F:Microsoft.CodeAnalysis.OperationKind.TypeOf +F:Microsoft.CodeAnalysis.OperationKind.TypeParameterObjectCreation +F:Microsoft.CodeAnalysis.OperationKind.TypePattern +F:Microsoft.CodeAnalysis.OperationKind.Unary +F:Microsoft.CodeAnalysis.OperationKind.UnaryOperator +F:Microsoft.CodeAnalysis.OperationKind.Using +F:Microsoft.CodeAnalysis.OperationKind.UsingDeclaration +F:Microsoft.CodeAnalysis.OperationKind.Utf8String +F:Microsoft.CodeAnalysis.OperationKind.value__ +F:Microsoft.CodeAnalysis.OperationKind.VariableDeclaration +F:Microsoft.CodeAnalysis.OperationKind.VariableDeclarationGroup +F:Microsoft.CodeAnalysis.OperationKind.VariableDeclarator +F:Microsoft.CodeAnalysis.OperationKind.VariableInitializer +F:Microsoft.CodeAnalysis.OperationKind.With +F:Microsoft.CodeAnalysis.OperationKind.YieldBreak +F:Microsoft.CodeAnalysis.OperationKind.YieldReturn +F:Microsoft.CodeAnalysis.Operations.ArgumentKind.DefaultValue +F:Microsoft.CodeAnalysis.Operations.ArgumentKind.Explicit +F:Microsoft.CodeAnalysis.Operations.ArgumentKind.None +F:Microsoft.CodeAnalysis.Operations.ArgumentKind.ParamArray +F:Microsoft.CodeAnalysis.Operations.ArgumentKind.ParamCollection +F:Microsoft.CodeAnalysis.Operations.ArgumentKind.value__ +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Add +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.And +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Concatenate +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ConditionalAnd +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ConditionalOr +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Divide +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Equals +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ExclusiveOr +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.GreaterThan +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.GreaterThanOrEqual +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.IntegerDivide +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LeftShift +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LessThan +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LessThanOrEqual +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Like +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Multiply +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.None +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.NotEquals +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ObjectValueEquals +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ObjectValueNotEquals +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Or +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Power +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Remainder +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.RightShift +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Subtract +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.UnsignedRightShift +F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.value__ +F:Microsoft.CodeAnalysis.Operations.BranchKind.Break +F:Microsoft.CodeAnalysis.Operations.BranchKind.Continue +F:Microsoft.CodeAnalysis.Operations.BranchKind.GoTo +F:Microsoft.CodeAnalysis.Operations.BranchKind.None +F:Microsoft.CodeAnalysis.Operations.BranchKind.value__ +F:Microsoft.CodeAnalysis.Operations.CaseKind.Default +F:Microsoft.CodeAnalysis.Operations.CaseKind.None +F:Microsoft.CodeAnalysis.Operations.CaseKind.Pattern +F:Microsoft.CodeAnalysis.Operations.CaseKind.Range +F:Microsoft.CodeAnalysis.Operations.CaseKind.Relational +F:Microsoft.CodeAnalysis.Operations.CaseKind.SingleValue +F:Microsoft.CodeAnalysis.Operations.CaseKind.value__ +F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.ContainingTypeInstance +F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.ImplicitReceiver +F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.InterpolatedStringHandler +F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.PatternInput +F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.value__ +F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.CallsiteArgument +F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.CallsiteReceiver +F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.TrailingValidityArgument +F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.value__ +F:Microsoft.CodeAnalysis.Operations.LoopKind.For +F:Microsoft.CodeAnalysis.Operations.LoopKind.ForEach +F:Microsoft.CodeAnalysis.Operations.LoopKind.ForTo +F:Microsoft.CodeAnalysis.Operations.LoopKind.None +F:Microsoft.CodeAnalysis.Operations.LoopKind.value__ +F:Microsoft.CodeAnalysis.Operations.LoopKind.While +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.BitwiseNegation +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.False +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Hat +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Minus +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.None +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Not +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Plus +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.True +F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.value__ +F:Microsoft.CodeAnalysis.OptimizationLevel.Debug +F:Microsoft.CodeAnalysis.OptimizationLevel.Release +F:Microsoft.CodeAnalysis.OptimizationLevel.value__ +F:Microsoft.CodeAnalysis.OutputKind.ConsoleApplication +F:Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary +F:Microsoft.CodeAnalysis.OutputKind.NetModule +F:Microsoft.CodeAnalysis.OutputKind.value__ +F:Microsoft.CodeAnalysis.OutputKind.WindowsApplication +F:Microsoft.CodeAnalysis.OutputKind.WindowsRuntimeApplication +F:Microsoft.CodeAnalysis.OutputKind.WindowsRuntimeMetadata +F:Microsoft.CodeAnalysis.Platform.AnyCpu +F:Microsoft.CodeAnalysis.Platform.AnyCpu32BitPreferred +F:Microsoft.CodeAnalysis.Platform.Arm +F:Microsoft.CodeAnalysis.Platform.Arm64 +F:Microsoft.CodeAnalysis.Platform.Itanium +F:Microsoft.CodeAnalysis.Platform.value__ +F:Microsoft.CodeAnalysis.Platform.X64 +F:Microsoft.CodeAnalysis.Platform.X86 +F:Microsoft.CodeAnalysis.RefKind.In +F:Microsoft.CodeAnalysis.RefKind.None +F:Microsoft.CodeAnalysis.RefKind.Out +F:Microsoft.CodeAnalysis.RefKind.Ref +F:Microsoft.CodeAnalysis.RefKind.RefReadOnly +F:Microsoft.CodeAnalysis.RefKind.RefReadOnlyParameter +F:Microsoft.CodeAnalysis.RefKind.value__ +F:Microsoft.CodeAnalysis.ReportDiagnostic.Default +F:Microsoft.CodeAnalysis.ReportDiagnostic.Error +F:Microsoft.CodeAnalysis.ReportDiagnostic.Hidden +F:Microsoft.CodeAnalysis.ReportDiagnostic.Info +F:Microsoft.CodeAnalysis.ReportDiagnostic.Suppress +F:Microsoft.CodeAnalysis.ReportDiagnostic.value__ +F:Microsoft.CodeAnalysis.ReportDiagnostic.Warn +F:Microsoft.CodeAnalysis.RuntimeCapability.ByRefFields +F:Microsoft.CodeAnalysis.RuntimeCapability.ByRefLikeGenerics +F:Microsoft.CodeAnalysis.RuntimeCapability.CovariantReturnsOfClasses +F:Microsoft.CodeAnalysis.RuntimeCapability.DefaultImplementationsOfInterfaces +F:Microsoft.CodeAnalysis.RuntimeCapability.InlineArrayTypes +F:Microsoft.CodeAnalysis.RuntimeCapability.NumericIntPtr +F:Microsoft.CodeAnalysis.RuntimeCapability.UnmanagedSignatureCallingConvention +F:Microsoft.CodeAnalysis.RuntimeCapability.value__ +F:Microsoft.CodeAnalysis.RuntimeCapability.VirtualStaticsInInterfaces +F:Microsoft.CodeAnalysis.SarifVersion.Default +F:Microsoft.CodeAnalysis.SarifVersion.Latest +F:Microsoft.CodeAnalysis.SarifVersion.Sarif1 +F:Microsoft.CodeAnalysis.SarifVersion.Sarif2 +F:Microsoft.CodeAnalysis.SarifVersion.value__ +F:Microsoft.CodeAnalysis.ScopedKind.None +F:Microsoft.CodeAnalysis.ScopedKind.ScopedRef +F:Microsoft.CodeAnalysis.ScopedKind.ScopedValue +F:Microsoft.CodeAnalysis.ScopedKind.value__ +F:Microsoft.CodeAnalysis.SemanticModelOptions.DisableNullableAnalysis +F:Microsoft.CodeAnalysis.SemanticModelOptions.IgnoreAccessibility +F:Microsoft.CodeAnalysis.SemanticModelOptions.None +F:Microsoft.CodeAnalysis.SemanticModelOptions.value__ +F:Microsoft.CodeAnalysis.SourceCodeKind.Interactive +F:Microsoft.CodeAnalysis.SourceCodeKind.Regular +F:Microsoft.CodeAnalysis.SourceCodeKind.Script +F:Microsoft.CodeAnalysis.SourceCodeKind.value__ +F:Microsoft.CodeAnalysis.SpecialType.Count +F:Microsoft.CodeAnalysis.SpecialType.None +F:Microsoft.CodeAnalysis.SpecialType.System_ArgIterator +F:Microsoft.CodeAnalysis.SpecialType.System_Array +F:Microsoft.CodeAnalysis.SpecialType.System_AsyncCallback +F:Microsoft.CodeAnalysis.SpecialType.System_Boolean +F:Microsoft.CodeAnalysis.SpecialType.System_Byte +F:Microsoft.CodeAnalysis.SpecialType.System_Char +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_ICollection_T +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IEnumerable_T +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IEnumerator_T +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IList_T +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IReadOnlyCollection_T +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IReadOnlyList_T +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_IEnumerable +F:Microsoft.CodeAnalysis.SpecialType.System_Collections_IEnumerator +F:Microsoft.CodeAnalysis.SpecialType.System_DateTime +F:Microsoft.CodeAnalysis.SpecialType.System_Decimal +F:Microsoft.CodeAnalysis.SpecialType.System_Delegate +F:Microsoft.CodeAnalysis.SpecialType.System_Double +F:Microsoft.CodeAnalysis.SpecialType.System_Enum +F:Microsoft.CodeAnalysis.SpecialType.System_IAsyncResult +F:Microsoft.CodeAnalysis.SpecialType.System_IDisposable +F:Microsoft.CodeAnalysis.SpecialType.System_Int16 +F:Microsoft.CodeAnalysis.SpecialType.System_Int32 +F:Microsoft.CodeAnalysis.SpecialType.System_Int64 +F:Microsoft.CodeAnalysis.SpecialType.System_IntPtr +F:Microsoft.CodeAnalysis.SpecialType.System_MulticastDelegate +F:Microsoft.CodeAnalysis.SpecialType.System_Nullable_T +F:Microsoft.CodeAnalysis.SpecialType.System_Object +F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute +F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_IsVolatile +F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute +F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_RuntimeFeature +F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeArgumentHandle +F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeFieldHandle +F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeMethodHandle +F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeTypeHandle +F:Microsoft.CodeAnalysis.SpecialType.System_SByte +F:Microsoft.CodeAnalysis.SpecialType.System_Single +F:Microsoft.CodeAnalysis.SpecialType.System_String +F:Microsoft.CodeAnalysis.SpecialType.System_TypedReference +F:Microsoft.CodeAnalysis.SpecialType.System_UInt16 +F:Microsoft.CodeAnalysis.SpecialType.System_UInt32 +F:Microsoft.CodeAnalysis.SpecialType.System_UInt64 +F:Microsoft.CodeAnalysis.SpecialType.System_UIntPtr +F:Microsoft.CodeAnalysis.SpecialType.System_ValueType +F:Microsoft.CodeAnalysis.SpecialType.System_Void +F:Microsoft.CodeAnalysis.SpecialType.value__ +F:Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsExpression +F:Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsTypeOrNamespace +F:Microsoft.CodeAnalysis.SpeculativeBindingOption.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameAndParameters +F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameAndSignature +F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameOnly +F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.Default +F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.InstanceMethod +F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.StaticMethod +F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeTypeConstraints +F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeTypeParameters +F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeVariance +F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.None +F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.Included +F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.Omitted +F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining +F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeMemberKeyword +F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeNamespaceKeyword +F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeTypeKeyword +F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.None +F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeConstantValue +F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeModifiers +F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeRef +F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeType +F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.None +F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeAccessibility +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeConstantValue +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeContainingType +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeExplicitInterface +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeModifiers +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeParameters +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeRef +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeType +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.None +F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.CollapseTupleTypes +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.ExpandNullable +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.ExpandValueTuple +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.IncludeNotNullableReferenceTypeModifier +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.None +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.RemoveAttributeSuffix +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseAsterisksInMultiDimensionalArrays +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseErrorTypeSymbolName +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseSpecialTypes +F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeDefaultValue +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeExtensionThis +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeModifiers +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeName +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeOptionalBrackets +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeParamsRefOut +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeType +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.None +F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.AliasName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.AnonymousTypeIndicator +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.AssemblyName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ClassName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ConstantName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.DelegateName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.EnumMemberName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.EnumName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ErrorTypeName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.EventName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ExtensionMethodName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.FieldName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.InterfaceName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Keyword +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.LabelName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.LineBreak +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.LocalName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.MethodName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ModuleName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.NamespaceName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.NumericLiteral +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Operator +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ParameterName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.PropertyName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Punctuation +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.RangeVariableName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordClassName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordStructName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Space +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.StringLiteral +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.StructName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Text +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.TypeParameterName +F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.NameOnly +F:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.ShowReadWriteDescriptor +F:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.value__ +F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameAndContainingTypes +F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces +F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameOnly +F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.value__ +F:Microsoft.CodeAnalysis.SymbolEqualityComparer.Default +F:Microsoft.CodeAnalysis.SymbolEqualityComparer.IncludeNullability +F:Microsoft.CodeAnalysis.SymbolFilter.All +F:Microsoft.CodeAnalysis.SymbolFilter.Member +F:Microsoft.CodeAnalysis.SymbolFilter.Namespace +F:Microsoft.CodeAnalysis.SymbolFilter.None +F:Microsoft.CodeAnalysis.SymbolFilter.Type +F:Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember +F:Microsoft.CodeAnalysis.SymbolFilter.value__ +F:Microsoft.CodeAnalysis.SymbolKind.Alias +F:Microsoft.CodeAnalysis.SymbolKind.ArrayType +F:Microsoft.CodeAnalysis.SymbolKind.Assembly +F:Microsoft.CodeAnalysis.SymbolKind.Discard +F:Microsoft.CodeAnalysis.SymbolKind.DynamicType +F:Microsoft.CodeAnalysis.SymbolKind.ErrorType +F:Microsoft.CodeAnalysis.SymbolKind.Event +F:Microsoft.CodeAnalysis.SymbolKind.Field +F:Microsoft.CodeAnalysis.SymbolKind.FunctionPointerType +F:Microsoft.CodeAnalysis.SymbolKind.Label +F:Microsoft.CodeAnalysis.SymbolKind.Local +F:Microsoft.CodeAnalysis.SymbolKind.Method +F:Microsoft.CodeAnalysis.SymbolKind.NamedType +F:Microsoft.CodeAnalysis.SymbolKind.Namespace +F:Microsoft.CodeAnalysis.SymbolKind.NetModule +F:Microsoft.CodeAnalysis.SymbolKind.Parameter +F:Microsoft.CodeAnalysis.SymbolKind.PointerType +F:Microsoft.CodeAnalysis.SymbolKind.Preprocessing +F:Microsoft.CodeAnalysis.SymbolKind.Property +F:Microsoft.CodeAnalysis.SymbolKind.RangeVariable +F:Microsoft.CodeAnalysis.SymbolKind.TypeParameter +F:Microsoft.CodeAnalysis.SymbolKind.value__ +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.AddElasticMarker +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepDirectives +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepEndOfLine +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepExteriorTrivia +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepLeadingTrivia +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepNoTrivia +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepTrailingTrivia +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepUnbalancedDirectives +F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.value__ +F:Microsoft.CodeAnalysis.SyntaxTree.EmptyDiagnosticOptions +F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.Node +F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.StructuredTrivia +F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.Token +F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.Trivia +F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.value__ +F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.None +F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha1 +F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha256 +F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.value__ +F:Microsoft.CodeAnalysis.TypedConstantKind.Array +F:Microsoft.CodeAnalysis.TypedConstantKind.Enum +F:Microsoft.CodeAnalysis.TypedConstantKind.Error +F:Microsoft.CodeAnalysis.TypedConstantKind.Primitive +F:Microsoft.CodeAnalysis.TypedConstantKind.Type +F:Microsoft.CodeAnalysis.TypedConstantKind.value__ +F:Microsoft.CodeAnalysis.TypeKind.Array +F:Microsoft.CodeAnalysis.TypeKind.Class +F:Microsoft.CodeAnalysis.TypeKind.Delegate +F:Microsoft.CodeAnalysis.TypeKind.Dynamic +F:Microsoft.CodeAnalysis.TypeKind.Enum +F:Microsoft.CodeAnalysis.TypeKind.Error +F:Microsoft.CodeAnalysis.TypeKind.FunctionPointer +F:Microsoft.CodeAnalysis.TypeKind.Interface +F:Microsoft.CodeAnalysis.TypeKind.Module +F:Microsoft.CodeAnalysis.TypeKind.Pointer +F:Microsoft.CodeAnalysis.TypeKind.Struct +F:Microsoft.CodeAnalysis.TypeKind.Structure +F:Microsoft.CodeAnalysis.TypeKind.Submission +F:Microsoft.CodeAnalysis.TypeKind.TypeParameter +F:Microsoft.CodeAnalysis.TypeKind.Unknown +F:Microsoft.CodeAnalysis.TypeKind.value__ +F:Microsoft.CodeAnalysis.TypeParameterKind.Cref +F:Microsoft.CodeAnalysis.TypeParameterKind.Method +F:Microsoft.CodeAnalysis.TypeParameterKind.Type +F:Microsoft.CodeAnalysis.TypeParameterKind.value__ +F:Microsoft.CodeAnalysis.VarianceKind.In +F:Microsoft.CodeAnalysis.VarianceKind.None +F:Microsoft.CodeAnalysis.VarianceKind.Out +F:Microsoft.CodeAnalysis.VarianceKind.value__ +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.AnalyzerException +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Build +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CompilationEnd +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Compiler +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CustomObsolete +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CustomSeverityConfigurable +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.EditAndContinue +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.NotConfigurable +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Telemetry +F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Unnecessary +F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.AdditionalTexts +F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.AnalyzerConfigOptions +F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.Compilation +F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.MetadataReferences +F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.ParseOptions +F:Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.ImplementationSourceOutput +F:Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.SourceOutput +F:Microsoft.CodeAnalysis.WellKnownMemberNames.AdditionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.BitwiseAndOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.BitwiseOrOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedAdditionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedDecrementOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedDivisionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedExplicitConversionName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedIncrementOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedMultiplyOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedSubtractionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedUnaryNegationOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CollectionInitializerAddMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ConcatenateOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CountPropertyName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.CurrentPropertyName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DeconstructMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DecrementOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DefaultScriptClassName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateBeginInvokeName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateEndInvokeName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateInvokeName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DestructorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DisposeAsyncMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DisposeMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.DivisionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.EntryPointMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.EnumBackingFieldName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.EqualityOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ExclusiveOrOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ExplicitConversionName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ExponentOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.FalseOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetAsyncEnumeratorMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetAwaiter +F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetEnumeratorMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetResult +F:Microsoft.CodeAnalysis.WellKnownMemberNames.GreaterThanOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.GreaterThanOrEqualOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ImplicitConversionName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.IncrementOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.Indexer +F:Microsoft.CodeAnalysis.WellKnownMemberNames.InequalityOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.InstanceConstructorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.IntegerDivisionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.IsCompleted +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LeftShiftOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LengthPropertyName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LessThanOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LessThanOrEqualOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LikeOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalAndOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalNotOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalOrOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ModulusOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextAsyncMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.MultiplyOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectEquals +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectGetHashCode +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectToString +F:Microsoft.CodeAnalysis.WellKnownMemberNames.OnCompleted +F:Microsoft.CodeAnalysis.WellKnownMemberNames.OnesComplementOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.PrintMembersMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.RightShiftOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.SliceMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.StaticConstructorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.SubtractionOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.TopLevelStatementsEntryPointMethodName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.TopLevelStatementsEntryPointTypeName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.TrueOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnaryNegationOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnaryPlusOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnsignedLeftShiftOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnsignedRightShiftOperatorName +F:Microsoft.CodeAnalysis.WellKnownMemberNames.ValuePropertyName +M:Microsoft.CodeAnalysis.AdditionalText.#ctor +M:Microsoft.CodeAnalysis.AdditionalText.get_Path +M:Microsoft.CodeAnalysis.AdditionalText.GetText(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.AnalyzerConfig.Parse(Microsoft.CodeAnalysis.Text.SourceText,System.String) +M:Microsoft.CodeAnalysis.AnalyzerConfig.Parse(System.String,System.String) +M:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_AnalyzerOptions +M:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_Diagnostics +M:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_TreeOptions +M:Microsoft.CodeAnalysis.AnalyzerConfigSet.Create``1(``0) +M:Microsoft.CodeAnalysis.AnalyzerConfigSet.Create``1(``0,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic}@) +M:Microsoft.CodeAnalysis.AnalyzerConfigSet.get_GlobalConfigOptions +M:Microsoft.CodeAnalysis.AnalyzerConfigSet.GetOptionsForSourcePath(System.String) +M:Microsoft.CodeAnalysis.AnnotationExtensions.WithAdditionalAnnotations``1(``0,Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.AnnotationExtensions.WithAdditionalAnnotations``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,System.String) +M:Microsoft.CodeAnalysis.AssemblyIdentity.#ctor(System.String,System.Version,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Boolean,System.Boolean,System.Reflection.AssemblyContentType) +M:Microsoft.CodeAnalysis.AssemblyIdentity.Equals(Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.AssemblyIdentity.Equals(System.Object) +M:Microsoft.CodeAnalysis.AssemblyIdentity.FromAssemblyDefinition(System.Reflection.Assembly) +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_ContentType +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_CultureName +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_Flags +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_HasPublicKey +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_IsRetargetable +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_IsStrongName +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_Name +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_PublicKey +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_PublicKeyToken +M:Microsoft.CodeAnalysis.AssemblyIdentity.get_Version +M:Microsoft.CodeAnalysis.AssemblyIdentity.GetDisplayName(System.Boolean) +M:Microsoft.CodeAnalysis.AssemblyIdentity.GetHashCode +M:Microsoft.CodeAnalysis.AssemblyIdentity.op_Equality(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.AssemblyIdentity.op_Inequality(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.AssemblyIdentity.ToString +M:Microsoft.CodeAnalysis.AssemblyIdentity.TryParseDisplayName(System.String,Microsoft.CodeAnalysis.AssemblyIdentity@) +M:Microsoft.CodeAnalysis.AssemblyIdentity.TryParseDisplayName(System.String,Microsoft.CodeAnalysis.AssemblyIdentity@,Microsoft.CodeAnalysis.AssemblyIdentityParts@) +M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.Compare(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_CultureComparer +M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_Default +M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_SimpleNameComparer +M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ReferenceMatchesDefinition(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ReferenceMatchesDefinition(System.String,Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.AssemblyMetadata.CommonCopy +M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(Microsoft.CodeAnalysis.ModuleMetadata) +M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(Microsoft.CodeAnalysis.ModuleMetadata[]) +M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ModuleMetadata}) +M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ModuleMetadata}) +M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromFile(System.String) +M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromImage(System.Collections.Generic.IEnumerable{System.Byte}) +M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromImage(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromStream(System.IO.Stream,System.Boolean) +M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromStream(System.IO.Stream,System.Reflection.PortableExecutable.PEStreamOptions) +M:Microsoft.CodeAnalysis.AssemblyMetadata.Dispose +M:Microsoft.CodeAnalysis.AssemblyMetadata.get_Kind +M:Microsoft.CodeAnalysis.AssemblyMetadata.GetModules +M:Microsoft.CodeAnalysis.AssemblyMetadata.GetReference(Microsoft.CodeAnalysis.DocumentationProvider,System.Collections.Immutable.ImmutableArray{System.String},System.Boolean,System.String,System.String) +M:Microsoft.CodeAnalysis.AttributeData.#ctor +M:Microsoft.CodeAnalysis.AttributeData.get_ApplicationSyntaxReference +M:Microsoft.CodeAnalysis.AttributeData.get_AttributeClass +M:Microsoft.CodeAnalysis.AttributeData.get_AttributeConstructor +M:Microsoft.CodeAnalysis.AttributeData.get_CommonApplicationSyntaxReference +M:Microsoft.CodeAnalysis.AttributeData.get_CommonAttributeClass +M:Microsoft.CodeAnalysis.AttributeData.get_CommonAttributeConstructor +M:Microsoft.CodeAnalysis.AttributeData.get_CommonConstructorArguments +M:Microsoft.CodeAnalysis.AttributeData.get_CommonNamedArguments +M:Microsoft.CodeAnalysis.AttributeData.get_ConstructorArguments +M:Microsoft.CodeAnalysis.AttributeData.get_NamedArguments +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.String,System.String) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.EndsWith(System.String,System.String) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.String,System.String) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.get_Comparer +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.GetHashCode(System.String) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.StartsWith(System.String,System.String) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.Char) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.String) +M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.Text.StringBuilder) +M:Microsoft.CodeAnalysis.ChildSyntaxList.Any +M:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.get_Current +M:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.Reset +M:Microsoft.CodeAnalysis.ChildSyntaxList.Equals(Microsoft.CodeAnalysis.ChildSyntaxList) +M:Microsoft.CodeAnalysis.ChildSyntaxList.Equals(System.Object) +M:Microsoft.CodeAnalysis.ChildSyntaxList.First +M:Microsoft.CodeAnalysis.ChildSyntaxList.get_Count +M:Microsoft.CodeAnalysis.ChildSyntaxList.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.ChildSyntaxList.GetEnumerator +M:Microsoft.CodeAnalysis.ChildSyntaxList.GetHashCode +M:Microsoft.CodeAnalysis.ChildSyntaxList.Last +M:Microsoft.CodeAnalysis.ChildSyntaxList.op_Equality(Microsoft.CodeAnalysis.ChildSyntaxList,Microsoft.CodeAnalysis.ChildSyntaxList) +M:Microsoft.CodeAnalysis.ChildSyntaxList.op_Inequality(Microsoft.CodeAnalysis.ChildSyntaxList,Microsoft.CodeAnalysis.ChildSyntaxList) +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reverse +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.get_Current +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.Reset +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Equals(Microsoft.CodeAnalysis.ChildSyntaxList.Reversed) +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Equals(System.Object) +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.GetEnumerator +M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.GetHashCode +M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.#ctor(System.String) +M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.Equals(Microsoft.CodeAnalysis.CommandLineAnalyzerReference) +M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.Equals(System.Object) +M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.get_FilePath +M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.GetHashCode +M:Microsoft.CodeAnalysis.CommandLineArguments.get_AdditionalFiles +M:Microsoft.CodeAnalysis.CommandLineArguments.get_AnalyzerConfigPaths +M:Microsoft.CodeAnalysis.CommandLineArguments.get_AnalyzerReferences +M:Microsoft.CodeAnalysis.CommandLineArguments.get_AppConfigPath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_BaseDirectory +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ChecksumAlgorithm +M:Microsoft.CodeAnalysis.CommandLineArguments.get_CompilationName +M:Microsoft.CodeAnalysis.CommandLineArguments.get_CompilationOptions +M:Microsoft.CodeAnalysis.CommandLineArguments.get_CompilationOptionsCore +M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayHelp +M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayLangVersions +M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayLogo +M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayVersion +M:Microsoft.CodeAnalysis.CommandLineArguments.get_DocumentationPath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmbeddedFiles +M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmitOptions +M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmitPdb +M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmitPdbFile +M:Microsoft.CodeAnalysis.CommandLineArguments.get_Encoding +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ErrorLogOptions +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ErrorLogPath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_Errors +M:Microsoft.CodeAnalysis.CommandLineArguments.get_GeneratedFilesOutputDirectory +M:Microsoft.CodeAnalysis.CommandLineArguments.get_InteractiveMode +M:Microsoft.CodeAnalysis.CommandLineArguments.get_KeyFileSearchPaths +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ManifestResources +M:Microsoft.CodeAnalysis.CommandLineArguments.get_MetadataReferences +M:Microsoft.CodeAnalysis.CommandLineArguments.get_NoWin32Manifest +M:Microsoft.CodeAnalysis.CommandLineArguments.get_OutputDirectory +M:Microsoft.CodeAnalysis.CommandLineArguments.get_OutputFileName +M:Microsoft.CodeAnalysis.CommandLineArguments.get_OutputRefFilePath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ParseOptions +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ParseOptionsCore +M:Microsoft.CodeAnalysis.CommandLineArguments.get_PathMap +M:Microsoft.CodeAnalysis.CommandLineArguments.get_PdbPath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_PreferredUILang +M:Microsoft.CodeAnalysis.CommandLineArguments.get_PrintFullPaths +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ReferencePaths +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ReportAnalyzer +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ReportInternalsVisibleToAttributes +M:Microsoft.CodeAnalysis.CommandLineArguments.get_RuleSetPath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_ScriptArguments +M:Microsoft.CodeAnalysis.CommandLineArguments.get_SkipAnalyzers +M:Microsoft.CodeAnalysis.CommandLineArguments.get_SourceFiles +M:Microsoft.CodeAnalysis.CommandLineArguments.get_SourceLink +M:Microsoft.CodeAnalysis.CommandLineArguments.get_SourcePaths +M:Microsoft.CodeAnalysis.CommandLineArguments.get_TouchedFilesPath +M:Microsoft.CodeAnalysis.CommandLineArguments.get_Utf8Output +M:Microsoft.CodeAnalysis.CommandLineArguments.get_Win32Icon +M:Microsoft.CodeAnalysis.CommandLineArguments.get_Win32Manifest +M:Microsoft.CodeAnalysis.CommandLineArguments.get_Win32ResourceFile +M:Microsoft.CodeAnalysis.CommandLineArguments.GetOutputFilePath(System.String) +M:Microsoft.CodeAnalysis.CommandLineArguments.GetPdbFilePath(System.String) +M:Microsoft.CodeAnalysis.CommandLineArguments.ResolveAnalyzerReferences(Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader) +M:Microsoft.CodeAnalysis.CommandLineArguments.ResolveMetadataReferences(Microsoft.CodeAnalysis.MetadataReferenceResolver) +M:Microsoft.CodeAnalysis.CommandLineReference.#ctor(System.String,Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.CommandLineReference.Equals(Microsoft.CodeAnalysis.CommandLineReference) +M:Microsoft.CodeAnalysis.CommandLineReference.Equals(System.Object) +M:Microsoft.CodeAnalysis.CommandLineReference.get_Properties +M:Microsoft.CodeAnalysis.CommandLineReference.get_Reference +M:Microsoft.CodeAnalysis.CommandLineReference.GetHashCode +M:Microsoft.CodeAnalysis.CommandLineSourceFile.#ctor(System.String,System.Boolean) +M:Microsoft.CodeAnalysis.CommandLineSourceFile.#ctor(System.String,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.CommandLineSourceFile.get_IsInputRedirected +M:Microsoft.CodeAnalysis.CommandLineSourceFile.get_IsScript +M:Microsoft.CodeAnalysis.CommandLineSourceFile.get_Path +M:Microsoft.CodeAnalysis.Compilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference[]) +M:Microsoft.CodeAnalysis.Compilation.AddReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.Compilation.AddSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +M:Microsoft.CodeAnalysis.Compilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.Compilation.AppendDefaultVersionResource(System.IO.Stream) +M:Microsoft.CodeAnalysis.Compilation.CheckTupleElementLocations(System.Int32,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +M:Microsoft.CodeAnalysis.Compilation.CheckTupleElementNames(System.Int32,System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.Compilation.CheckTupleElementNullableAnnotations(System.Int32,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.Clone +M:Microsoft.CodeAnalysis.Compilation.CommonAddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.Compilation.CommonBindScriptClass +M:Microsoft.CodeAnalysis.Compilation.CommonClone +M:Microsoft.CodeAnalysis.Compilation.CommonContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateNativeIntegerTypeSymbol(System.Boolean) +M:Microsoft.CodeAnalysis.Compilation.CommonCreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.CommonCreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.CommonGetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) +M:Microsoft.CodeAnalysis.Compilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +M:Microsoft.CodeAnalysis.Compilation.CommonGetEntryPoint(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +M:Microsoft.CodeAnalysis.Compilation.CommonGetTypeByMetadataName(System.String) +M:Microsoft.CodeAnalysis.Compilation.CommonRemoveAllSyntaxTrees +M:Microsoft.CodeAnalysis.Compilation.CommonRemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.Compilation.CommonReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.Compilation.CommonWithAssemblyName(System.String) +M:Microsoft.CodeAnalysis.Compilation.CommonWithOptions(Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.Compilation.CommonWithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.Compilation.CommonWithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) +M:Microsoft.CodeAnalysis.Compilation.ContainsSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.ContainsSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +M:Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.CreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32) +M:Microsoft.CodeAnalysis.Compilation.CreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) +M:Microsoft.CodeAnalysis.Compilation.CreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.CreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.CreateDefaultWin32Resources(System.Boolean,System.Boolean,System.IO.Stream,System.IO.Stream) +M:Microsoft.CodeAnalysis.Compilation.CreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) +M:Microsoft.CodeAnalysis.Compilation.CreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) +M:Microsoft.CodeAnalysis.Compilation.CreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) +M:Microsoft.CodeAnalysis.Compilation.CreateNativeIntegerTypeSymbol(System.Boolean) +M:Microsoft.CodeAnalysis.Compilation.CreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) +M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.IMethodSymbol,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.EmbeddedText},System.IO.Stream,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.IMethodSymbol,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.EmbeddedText},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Emit.SemanticEdit},System.Func{Microsoft.CodeAnalysis.ISymbol,System.Boolean},System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.ICollection{System.Reflection.Metadata.MethodDefinitionHandle},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Emit.SemanticEdit},System.Func{Microsoft.CodeAnalysis.ISymbol,System.Boolean},System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Emit.SemanticEdit},System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.ICollection{System.Reflection.Metadata.MethodDefinitionHandle},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.get_Assembly +M:Microsoft.CodeAnalysis.Compilation.get_AssemblyName +M:Microsoft.CodeAnalysis.Compilation.get_CommonAssembly +M:Microsoft.CodeAnalysis.Compilation.get_CommonDynamicType +M:Microsoft.CodeAnalysis.Compilation.get_CommonGlobalNamespace +M:Microsoft.CodeAnalysis.Compilation.get_CommonObjectType +M:Microsoft.CodeAnalysis.Compilation.get_CommonOptions +M:Microsoft.CodeAnalysis.Compilation.get_CommonScriptClass +M:Microsoft.CodeAnalysis.Compilation.get_CommonScriptGlobalsType +M:Microsoft.CodeAnalysis.Compilation.get_CommonSourceModule +M:Microsoft.CodeAnalysis.Compilation.get_CommonSyntaxTrees +M:Microsoft.CodeAnalysis.Compilation.get_DirectiveReferences +M:Microsoft.CodeAnalysis.Compilation.get_DynamicType +M:Microsoft.CodeAnalysis.Compilation.get_ExternalReferences +M:Microsoft.CodeAnalysis.Compilation.get_GlobalNamespace +M:Microsoft.CodeAnalysis.Compilation.get_IsCaseSensitive +M:Microsoft.CodeAnalysis.Compilation.get_Language +M:Microsoft.CodeAnalysis.Compilation.get_ObjectType +M:Microsoft.CodeAnalysis.Compilation.get_Options +M:Microsoft.CodeAnalysis.Compilation.get_ReferencedAssemblyNames +M:Microsoft.CodeAnalysis.Compilation.get_References +M:Microsoft.CodeAnalysis.Compilation.get_ScriptClass +M:Microsoft.CodeAnalysis.Compilation.get_ScriptCompilationInfo +M:Microsoft.CodeAnalysis.Compilation.get_SourceModule +M:Microsoft.CodeAnalysis.Compilation.get_SyntaxTrees +M:Microsoft.CodeAnalysis.Compilation.GetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) +M:Microsoft.CodeAnalysis.Compilation.GetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +M:Microsoft.CodeAnalysis.Compilation.GetDeclarationDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetEntryPoint(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol) +M:Microsoft.CodeAnalysis.Compilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetParseDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetRequiredLanguageVersion(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) +M:Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +M:Microsoft.CodeAnalysis.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType) +M:Microsoft.CodeAnalysis.Compilation.GetSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.GetTypeByMetadataName(System.String) +M:Microsoft.CodeAnalysis.Compilation.GetTypesByMetadataName(System.String) +M:Microsoft.CodeAnalysis.Compilation.GetUnreferencedAssemblyIdentities(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Compilation.GetUsedAssemblyReferences(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Compilation.HasImplicitConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.IsSymbolAccessibleWithin(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.Compilation.RemoveAllReferences +M:Microsoft.CodeAnalysis.Compilation.RemoveAllSyntaxTrees +M:Microsoft.CodeAnalysis.Compilation.RemoveReferences(Microsoft.CodeAnalysis.MetadataReference[]) +M:Microsoft.CodeAnalysis.Compilation.RemoveReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) +M:Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.Compilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.MetadataReference) +M:Microsoft.CodeAnalysis.Compilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.Compilation.SupportsRuntimeCapability(Microsoft.CodeAnalysis.RuntimeCapability) +M:Microsoft.CodeAnalysis.Compilation.SyntaxTreeCommonFeatures(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.Compilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) +M:Microsoft.CodeAnalysis.Compilation.WithAssemblyName(System.String) +M:Microsoft.CodeAnalysis.Compilation.WithOptions(Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.Compilation.WithReferences(Microsoft.CodeAnalysis.MetadataReference[]) +M:Microsoft.CodeAnalysis.Compilation.WithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) +M:Microsoft.CodeAnalysis.Compilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCheckOverflow(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithConcurrentBuild(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoKeyContainer(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoKeyFile(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithDelaySign(System.Nullable{System.Boolean}) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithDeterministic(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithFeatures(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithMainTypeName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithModuleName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithOutputKind(Microsoft.CodeAnalysis.OutputKind) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithPlatform(Microsoft.CodeAnalysis.Platform) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithPublicSign(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithReportSuppressedDiagnostics(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithScriptClassName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.ComputeHashCode +M:Microsoft.CodeAnalysis.CompilationOptions.Equals(System.Object) +M:Microsoft.CodeAnalysis.CompilationOptions.EqualsHelper(Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.get_AssemblyIdentityComparer +M:Microsoft.CodeAnalysis.CompilationOptions.get_CheckOverflow +M:Microsoft.CodeAnalysis.CompilationOptions.get_ConcurrentBuild +M:Microsoft.CodeAnalysis.CompilationOptions.get_CryptoKeyContainer +M:Microsoft.CodeAnalysis.CompilationOptions.get_CryptoKeyFile +M:Microsoft.CodeAnalysis.CompilationOptions.get_CryptoPublicKey +M:Microsoft.CodeAnalysis.CompilationOptions.get_DelaySign +M:Microsoft.CodeAnalysis.CompilationOptions.get_Deterministic +M:Microsoft.CodeAnalysis.CompilationOptions.get_Errors +M:Microsoft.CodeAnalysis.CompilationOptions.get_Features +M:Microsoft.CodeAnalysis.CompilationOptions.get_GeneralDiagnosticOption +M:Microsoft.CodeAnalysis.CompilationOptions.get_Language +M:Microsoft.CodeAnalysis.CompilationOptions.get_MainTypeName +M:Microsoft.CodeAnalysis.CompilationOptions.get_MetadataImportOptions +M:Microsoft.CodeAnalysis.CompilationOptions.get_MetadataReferenceResolver +M:Microsoft.CodeAnalysis.CompilationOptions.get_ModuleName +M:Microsoft.CodeAnalysis.CompilationOptions.get_NullableContextOptions +M:Microsoft.CodeAnalysis.CompilationOptions.get_OptimizationLevel +M:Microsoft.CodeAnalysis.CompilationOptions.get_OutputKind +M:Microsoft.CodeAnalysis.CompilationOptions.get_Platform +M:Microsoft.CodeAnalysis.CompilationOptions.get_PublicSign +M:Microsoft.CodeAnalysis.CompilationOptions.get_ReportSuppressedDiagnostics +M:Microsoft.CodeAnalysis.CompilationOptions.get_ScriptClassName +M:Microsoft.CodeAnalysis.CompilationOptions.get_SourceReferenceResolver +M:Microsoft.CodeAnalysis.CompilationOptions.get_SpecificDiagnosticOptions +M:Microsoft.CodeAnalysis.CompilationOptions.get_StrongNameProvider +M:Microsoft.CodeAnalysis.CompilationOptions.get_SyntaxTreeOptionsProvider +M:Microsoft.CodeAnalysis.CompilationOptions.get_WarningLevel +M:Microsoft.CodeAnalysis.CompilationOptions.get_XmlReferenceResolver +M:Microsoft.CodeAnalysis.CompilationOptions.GetHashCode +M:Microsoft.CodeAnalysis.CompilationOptions.GetHashCodeHelper +M:Microsoft.CodeAnalysis.CompilationOptions.op_Equality(Microsoft.CodeAnalysis.CompilationOptions,Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.op_Inequality(Microsoft.CodeAnalysis.CompilationOptions,Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.set_AssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +M:Microsoft.CodeAnalysis.CompilationOptions.set_CheckOverflow(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.set_ConcurrentBuild(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.set_CryptoKeyContainer(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.set_CryptoKeyFile(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.set_CryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.CompilationOptions.set_DelaySign(System.Nullable{System.Boolean}) +M:Microsoft.CodeAnalysis.CompilationOptions.set_Deterministic(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.set_Features(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.CompilationOptions.set_GeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.CompilationOptions.set_MainTypeName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.set_MetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.set_MetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.set_ModuleName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.set_NullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.set_OptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +M:Microsoft.CodeAnalysis.CompilationOptions.set_OutputKind(Microsoft.CodeAnalysis.OutputKind) +M:Microsoft.CodeAnalysis.CompilationOptions.set_Platform(Microsoft.CodeAnalysis.Platform) +M:Microsoft.CodeAnalysis.CompilationOptions.set_PublicSign(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.set_ReportSuppressedDiagnostics(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.set_ScriptClassName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.set_SourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.set_SpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.CompilationOptions.set_StrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CompilationOptions.set_SyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +M:Microsoft.CodeAnalysis.CompilationOptions.set_WarningLevel(System.Int32) +M:Microsoft.CodeAnalysis.CompilationOptions.set_XmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) +M:Microsoft.CodeAnalysis.CompilationOptions.WithConcurrentBuild(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoKeyContainer(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoKeyFile(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.CompilationOptions.WithDelaySign(System.Nullable{System.Boolean}) +M:Microsoft.CodeAnalysis.CompilationOptions.WithDeterministic(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.CompilationOptions.WithMainTypeName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) +M:Microsoft.CodeAnalysis.CompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.WithModuleName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) +M:Microsoft.CodeAnalysis.CompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind) +M:Microsoft.CodeAnalysis.CompilationOptions.WithOverflowChecks(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform) +M:Microsoft.CodeAnalysis.CompilationOptions.WithPublicSign(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.WithReportSuppressedDiagnostics(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationOptions.WithScriptClassName(System.String) +M:Microsoft.CodeAnalysis.CompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) +M:Microsoft.CodeAnalysis.CompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.CompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) +M:Microsoft.CodeAnalysis.CompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) +M:Microsoft.CodeAnalysis.CompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) +M:Microsoft.CodeAnalysis.CompilationReference.Equals(Microsoft.CodeAnalysis.CompilationReference) +M:Microsoft.CodeAnalysis.CompilationReference.Equals(System.Object) +M:Microsoft.CodeAnalysis.CompilationReference.get_Compilation +M:Microsoft.CodeAnalysis.CompilationReference.get_Display +M:Microsoft.CodeAnalysis.CompilationReference.GetHashCode +M:Microsoft.CodeAnalysis.CompilationReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.CompilationReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.CompilationReference.WithEmbedInteropTypes(System.Boolean) +M:Microsoft.CodeAnalysis.CompilationReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.#ctor +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_EndPointIsReachable +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_EntryPoints +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_ExitPoints +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_ReturnStatements +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_StartPointIsReachable +M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_Succeeded +M:Microsoft.CodeAnalysis.CustomModifier.#ctor +M:Microsoft.CodeAnalysis.CustomModifier.get_IsOptional +M:Microsoft.CodeAnalysis.CustomModifier.get_Modifier +M:Microsoft.CodeAnalysis.DataFlowAnalysis.#ctor +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_AlwaysAssigned +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_Captured +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_CapturedInside +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_CapturedOutside +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DataFlowsIn +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DataFlowsOut +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DefinitelyAssignedOnEntry +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DefinitelyAssignedOnExit +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_ReadInside +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_ReadOutside +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_Succeeded +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_UnsafeAddressTaken +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_UsedLocalFunctions +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_VariablesDeclared +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_WrittenInside +M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_WrittenOutside +M:Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.get_Default +M:Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.LoadFromXml(System.IO.Stream) +M:Microsoft.CodeAnalysis.Diagnostic.#ctor +M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) +M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) +M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Object[]) +M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) +M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Object[]) +M:Microsoft.CodeAnalysis.Diagnostic.Create(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.DiagnosticSeverity,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.Int32,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Generic.IEnumerable{System.String},System.Collections.Immutable.ImmutableDictionary{System.String,System.String}) +M:Microsoft.CodeAnalysis.Diagnostic.Create(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.DiagnosticSeverity,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.Int32,System.Boolean,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Generic.IEnumerable{System.String},System.Collections.Immutable.ImmutableDictionary{System.String,System.String}) +M:Microsoft.CodeAnalysis.Diagnostic.Equals(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostic.Equals(System.Object) +M:Microsoft.CodeAnalysis.Diagnostic.get_AdditionalLocations +M:Microsoft.CodeAnalysis.Diagnostic.get_DefaultSeverity +M:Microsoft.CodeAnalysis.Diagnostic.get_Descriptor +M:Microsoft.CodeAnalysis.Diagnostic.get_Id +M:Microsoft.CodeAnalysis.Diagnostic.get_IsSuppressed +M:Microsoft.CodeAnalysis.Diagnostic.get_IsWarningAsError +M:Microsoft.CodeAnalysis.Diagnostic.get_Location +M:Microsoft.CodeAnalysis.Diagnostic.get_Properties +M:Microsoft.CodeAnalysis.Diagnostic.get_Severity +M:Microsoft.CodeAnalysis.Diagnostic.get_WarningLevel +M:Microsoft.CodeAnalysis.Diagnostic.GetHashCode +M:Microsoft.CodeAnalysis.Diagnostic.GetMessage(System.IFormatProvider) +M:Microsoft.CodeAnalysis.Diagnostic.GetSuppressionInfo(Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.Diagnostic.ToString +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.#ctor(System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,Microsoft.CodeAnalysis.LocalizableString,System.String,System.String[]) +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.#ctor(System.String,System.String,System.String,System.String,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.String,System.String,System.String[]) +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.Equals(Microsoft.CodeAnalysis.DiagnosticDescriptor) +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.Equals(System.Object) +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Category +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_CustomTags +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_DefaultSeverity +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Description +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_HelpLinkUri +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Id +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_IsEnabledByDefault +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_MessageFormat +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Title +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.GetEffectiveSeverity(Microsoft.CodeAnalysis.CompilationOptions) +M:Microsoft.CodeAnalysis.DiagnosticDescriptor.GetHashCode +M:Microsoft.CodeAnalysis.DiagnosticFormatter.#ctor +M:Microsoft.CodeAnalysis.DiagnosticFormatter.Format(Microsoft.CodeAnalysis.Diagnostic,System.IFormatProvider) +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_AdditionalFile +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.AdditionalText,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.AdditionalText}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.ConfigureGeneratedCodeAnalysis(Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.EnableConcurrentExecution +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.get_MinimumReportedSeverity +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterAdditionalFileAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSemanticModelAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},Microsoft.CodeAnalysis.SymbolKind[]) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolKind}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext},Microsoft.CodeAnalysis.SymbolKind) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxTreeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_AdditionalFileDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_Analyzers +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_AnalyzerTelemetryInfo +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_CompilationDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_SemanticDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_SyntaxDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.GetAllDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.GetAllDiagnostics(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.get_KeyComparer +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.get_Keys +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.TryGetValue(System.String,System.String@) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.get_GlobalOptions +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.GetOptions(Microsoft.CodeAnalysis.AdditionalText) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.GetOptions(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.#ctor(System.String,Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.add_AnalyzerLoadFailed(System.EventHandler{Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(System.Object) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_AssemblyLoader +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_Display +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_FullPath +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_Id +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAnalyzers(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAnalyzersForAllLanguages +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAssembly +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGeneratorsForAllLanguages +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetHashCode +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.remove_AnalyzerLoadFailed(System.EventHandler{Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.String,System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_Display +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_FullPath +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_Id +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.GetAnalyzers(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.GetAnalyzersForAllLanguages +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode,System.String,System.Exception,System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_ErrorCode +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_Exception +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_Message +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_ReferencedCompilerVersion +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_TypeName +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.Equals(System.Object) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.get_AdditionalFiles +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.get_AnalyzerConfigOptionsProvider +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.GetHashCode +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.WithAdditionalFiles(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_Display +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_FullPath +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_Id +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetAnalyzers(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetAnalyzersForAllLanguages +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGeneratorsForAllLanguages +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_CodeBlock +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_OwningSymbol +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_SemanticModel +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_CodeBlock +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_OwningSymbol +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_SemanticModel +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterCodeBlockEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterSyntaxNodeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},`0[]) +M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterSyntaxNodeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{`0}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.#ctor(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.#ctor(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterAdditionalFileAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCompilationEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSemanticModelAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},Microsoft.CodeAnalysis.SymbolKind[]) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolKind}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext},Microsoft.CodeAnalysis.SymbolKind) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxTreeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.ClearAnalyzerState(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_AnalysisOptions +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_Analyzers +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAllDiagnosticsAsync +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAllDiagnosticsAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerCompilationDiagnosticsAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerCompilationDiagnosticsAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerTelemetryInfoAsync(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetEffectiveDiagnostics(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Diagnostic},Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetEffectiveDiagnostics(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic},Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.IsDiagnosticAnalyzerSuppressed(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.CompilationOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean,System.Boolean,System.Func{System.Exception,System.Boolean}) +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_AnalyzerExceptionFilter +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_ConcurrentAnalysis +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_LogAnalyzerExecutionTime +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_OnAnalyzerException +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_ReportSuppressedDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.Equals(System.Object) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.get_SupportedDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.GetHashCode +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.ToString +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute.#ctor(System.String,System.String[]) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute.get_Languages +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.get_SupportedDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.get_SupportedSuppressions +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext) +M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.ReportSuppressions(Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext) +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.#ctor(Microsoft.CodeAnalysis.IOperation,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_ContainingSymbol +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Operation +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.GetControlFlowGraph +M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.IOperation},Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_OperationBlocks +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_OwningSymbol +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.GetControlFlowGraph(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.IOperation},Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_OperationBlocks +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_OwningSymbol +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.GetControlFlowGraph(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationBlockEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.#ctor(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_SemanticModel +M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.Text.SourceText,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.Text.SourceText}) +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.Create(Microsoft.CodeAnalysis.SuppressionDescriptor,Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.Equals(Microsoft.CodeAnalysis.Diagnostics.Suppression) +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.Equals(System.Object) +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.get_Descriptor +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.get_SuppressedDiagnostic +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.GetHashCode +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.op_Equality(Microsoft.CodeAnalysis.Diagnostics.Suppression,Microsoft.CodeAnalysis.Diagnostics.Suppression) +M:Microsoft.CodeAnalysis.Diagnostics.Suppression.op_Inequality(Microsoft.CodeAnalysis.Diagnostics.Suppression,Microsoft.CodeAnalysis.Diagnostics.Suppression) +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_ReportedDiagnostics +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.ReportSuppression(Microsoft.CodeAnalysis.Diagnostics.Suppression) +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_Attribute +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_Id +M:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_ProgrammaticSuppressions +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.#ctor(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Symbol +M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.#ctor(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Symbol +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSymbolEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext}) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) +M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Compilation +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_ContainingSymbol +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_FilterTree +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Node +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_SemanticModel +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_CancellationToken +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_FilterSpan +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_IsGeneratedCode +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_Options +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_Tree +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.SyntaxTree,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.SyntaxTree}) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.#ctor +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_AdditionalFileActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockEndActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockStartActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationEndActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationStartActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_Concurrent +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_ExecutionTime +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockEndActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockStartActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SemanticModelActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SuppressionActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolEndActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolStartActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SyntaxNodeActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SyntaxTreeActionsCount +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_AdditionalFileActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockEndActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockStartActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationEndActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationStartActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_Concurrent(System.Boolean) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_ExecutionTime(System.TimeSpan) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockEndActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockStartActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SemanticModelActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SuppressionActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolEndActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolStartActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SyntaxNodeActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SyntaxTreeActionsCount(System.Int32) +M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.#ctor(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_Display +M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_FullPath +M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_Id +M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.GetAnalyzers(System.String) +M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.GetAnalyzersForAllLanguages +M:Microsoft.CodeAnalysis.DllImportData.get_BestFitMapping +M:Microsoft.CodeAnalysis.DllImportData.get_CallingConvention +M:Microsoft.CodeAnalysis.DllImportData.get_CharacterSet +M:Microsoft.CodeAnalysis.DllImportData.get_EntryPointName +M:Microsoft.CodeAnalysis.DllImportData.get_ExactSpelling +M:Microsoft.CodeAnalysis.DllImportData.get_ModuleName +M:Microsoft.CodeAnalysis.DllImportData.get_SetLastError +M:Microsoft.CodeAnalysis.DllImportData.get_ThrowOnUnmappableCharacter +M:Microsoft.CodeAnalysis.DocumentationCommentId.CreateDeclarationId(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.DocumentationCommentId.CreateReferenceId(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.DocumentationCommentId.GetFirstSymbolForDeclarationId(System.String,Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.DocumentationCommentId.GetFirstSymbolForReferenceId(System.String,Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.DocumentationCommentId.GetSymbolsForDeclarationId(System.String,Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.DocumentationCommentId.GetSymbolsForReferenceId(System.String,Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.DocumentationProvider.#ctor +M:Microsoft.CodeAnalysis.DocumentationProvider.Equals(System.Object) +M:Microsoft.CodeAnalysis.DocumentationProvider.get_Default +M:Microsoft.CodeAnalysis.DocumentationProvider.GetDocumentationForSymbol(System.String,System.Globalization.CultureInfo,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.DocumentationProvider.GetHashCode +M:Microsoft.CodeAnalysis.EmbeddedText.FromBytes(System.String,System.ArraySegment{System.Byte},Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +M:Microsoft.CodeAnalysis.EmbeddedText.FromSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.EmbeddedText.FromStream(System.String,System.IO.Stream,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +M:Microsoft.CodeAnalysis.EmbeddedText.get_Checksum +M:Microsoft.CodeAnalysis.EmbeddedText.get_ChecksumAlgorithm +M:Microsoft.CodeAnalysis.EmbeddedText.get_FilePath +M:Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation.Create(System.Collections.Immutable.ImmutableArray{System.Byte},System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation.Create(System.Collections.Immutable.ImmutableArray{System.Byte},System.Collections.Immutable.ImmutableArray{System.Byte},System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.Emit.EmitBaseline.CreateInitialBaseline(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.ModuleMetadata,System.Func{System.Reflection.Metadata.MethodDefinitionHandle,Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation},System.Func{System.Reflection.Metadata.MethodDefinitionHandle,System.Reflection.Metadata.StandaloneSignatureHandle},System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitBaseline.CreateInitialBaseline(Microsoft.CodeAnalysis.ModuleMetadata,System.Func{System.Reflection.Metadata.MethodDefinitionHandle,Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation}) +M:Microsoft.CodeAnalysis.Emit.EmitBaseline.CreateInitialBaseline(Microsoft.CodeAnalysis.ModuleMetadata,System.Func{System.Reflection.Metadata.MethodDefinitionHandle,Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation},System.Func{System.Reflection.Metadata.MethodDefinitionHandle,System.Reflection.Metadata.StandaloneSignatureHandle},System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitBaseline.get_OriginalMetadata +M:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.get_Baseline +M:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.get_ChangedTypes +M:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.get_UpdatedMethods +M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind}) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind},System.Nullable{System.Security.Cryptography.HashAlgorithmName}) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind},System.Nullable{System.Security.Cryptography.HashAlgorithmName},System.Text.Encoding,System.Text.Encoding) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.Equals(Microsoft.CodeAnalysis.Emit.EmitOptions) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.Equals(System.Object) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_BaseAddress +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_DebugInformationFormat +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_DefaultSourceFileEncoding +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_EmitMetadataOnly +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_FallbackSourceFileEncoding +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_FileAlignment +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_HighEntropyVirtualAddressSpace +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_IncludePrivateMembers +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_InstrumentationKinds +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_OutputNameOverride +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_PdbChecksumAlgorithm +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_PdbFilePath +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_RuntimeMetadataVersion +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_SubsystemVersion +M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_TolerateErrors +M:Microsoft.CodeAnalysis.Emit.EmitOptions.GetHashCode +M:Microsoft.CodeAnalysis.Emit.EmitOptions.op_Equality(Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.Emit.EmitOptions) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.op_Inequality(Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.Emit.EmitOptions) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithBaseAddress(System.UInt64) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithDebugInformationFormat(Microsoft.CodeAnalysis.Emit.DebugInformationFormat) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithDefaultSourceFileEncoding(System.Text.Encoding) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithEmitMetadataOnly(System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithFallbackSourceFileEncoding(System.Text.Encoding) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithFileAlignment(System.Int32) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithHighEntropyVirtualAddressSpace(System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithIncludePrivateMembers(System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithInstrumentationKinds(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind}) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithOutputNameOverride(System.String) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithPdbChecksumAlgorithm(System.Security.Cryptography.HashAlgorithmName) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithPdbFilePath(System.String) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithRuntimeMetadataVersion(System.String) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithSubsystemVersion(Microsoft.CodeAnalysis.SubsystemVersion) +M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithTolerateErrors(System.Boolean) +M:Microsoft.CodeAnalysis.Emit.EmitResult.get_Diagnostics +M:Microsoft.CodeAnalysis.Emit.EmitResult.get_Success +M:Microsoft.CodeAnalysis.Emit.EmitResult.GetDebuggerDisplay +M:Microsoft.CodeAnalysis.Emit.MethodInstrumentation.get_Kinds +M:Microsoft.CodeAnalysis.Emit.MethodInstrumentation.set_Kinds(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind}) +M:Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit.#ctor(System.String) +M:Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit.get_Message +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.#ctor(Microsoft.CodeAnalysis.Emit.SemanticEditKind,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.#ctor(Microsoft.CodeAnalysis.Emit.SemanticEditKind,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Boolean,Microsoft.CodeAnalysis.Emit.MethodInstrumentation) +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.#ctor(Microsoft.CodeAnalysis.Emit.SemanticEditKind,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Nullable{Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit}},Microsoft.CodeAnalysis.Emit.MethodInstrumentation) +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.Equals(Microsoft.CodeAnalysis.Emit.SemanticEdit) +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.Equals(System.Object) +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_Instrumentation +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_Kind +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_NewSymbol +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_OldSymbol +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_PreserveLocalVariables +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_RuntimeRudeEdit +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_SyntaxMap +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.GetHashCode +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.op_Equality(Microsoft.CodeAnalysis.Emit.SemanticEdit,Microsoft.CodeAnalysis.Emit.SemanticEdit) +M:Microsoft.CodeAnalysis.Emit.SemanticEdit.op_Inequality(Microsoft.CodeAnalysis.Emit.SemanticEdit,Microsoft.CodeAnalysis.Emit.SemanticEdit) +M:Microsoft.CodeAnalysis.ErrorLogOptions.#ctor(System.String,Microsoft.CodeAnalysis.SarifVersion) +M:Microsoft.CodeAnalysis.ErrorLogOptions.get_Path +M:Microsoft.CodeAnalysis.ErrorLogOptions.get_SarifVersion +M:Microsoft.CodeAnalysis.FileLinePositionSpan.#ctor(System.String,Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.FileLinePositionSpan.#ctor(System.String,Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.FileLinePositionSpan.Equals(Microsoft.CodeAnalysis.FileLinePositionSpan) +M:Microsoft.CodeAnalysis.FileLinePositionSpan.Equals(System.Object) +M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_EndLinePosition +M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_HasMappedPath +M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_IsValid +M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_Path +M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_Span +M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_StartLinePosition +M:Microsoft.CodeAnalysis.FileLinePositionSpan.GetHashCode +M:Microsoft.CodeAnalysis.FileLinePositionSpan.op_Equality(Microsoft.CodeAnalysis.FileLinePositionSpan,Microsoft.CodeAnalysis.FileLinePositionSpan) +M:Microsoft.CodeAnalysis.FileLinePositionSpan.op_Inequality(Microsoft.CodeAnalysis.FileLinePositionSpan,Microsoft.CodeAnalysis.FileLinePositionSpan) +M:Microsoft.CodeAnalysis.FileLinePositionSpan.ToString +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_BranchValue +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_ConditionalSuccessor +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_ConditionKind +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_EnclosingRegion +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_FallThroughSuccessor +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_IsReachable +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Kind +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Operations +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Ordinal +M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Predecessors +M:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.Equals(Microsoft.CodeAnalysis.FlowAnalysis.CaptureId) +M:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.Equals(System.Object) +M:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.GetHashCode +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Destination +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_EnteringRegions +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_FinallyRegions +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_IsConditionalSuccessor +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_LeavingRegions +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Semantics +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Source +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IAttributeOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IBlockOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Blocks +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_LocalFunctions +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_OriginalOperation +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Parent +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Root +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.GetAnonymousFunctionControlFlowGraph(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.GetLocalFunctionControlFlowGraph(Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions.GetAnonymousFunctionControlFlowGraphInScope(Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph,Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions.GetLocalFunctionControlFlowGraphInScope(Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph,Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_CaptureIds +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_EnclosingRegion +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_ExceptionType +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_FirstBlockOrdinal +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_Kind +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_LastBlockOrdinal +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_LocalFunctions +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_Locals +M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_NestedRegions +M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation.get_Symbol +M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation.get_Id +M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation.get_Value +M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation.get_Id +M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation.get_IsInitialization +M:Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation.get_Operand +M:Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation.get_Local +M:Microsoft.CodeAnalysis.GeneratedSourceResult.get_HintName +M:Microsoft.CodeAnalysis.GeneratedSourceResult.get_SourceText +M:Microsoft.CodeAnalysis.GeneratedSourceResult.get_SyntaxTree +M:Microsoft.CodeAnalysis.GeneratorAttribute.#ctor +M:Microsoft.CodeAnalysis.GeneratorAttribute.#ctor(System.String,System.String[]) +M:Microsoft.CodeAnalysis.GeneratorAttribute.get_Languages +M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_Attributes +M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_SemanticModel +M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_TargetNode +M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_TargetSymbol +M:Microsoft.CodeAnalysis.GeneratorDriver.AddAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +M:Microsoft.CodeAnalysis.GeneratorDriver.AddGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) +M:Microsoft.CodeAnalysis.GeneratorDriver.GetRunResult +M:Microsoft.CodeAnalysis.GeneratorDriver.GetTimingInfo +M:Microsoft.CodeAnalysis.GeneratorDriver.RemoveAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +M:Microsoft.CodeAnalysis.GeneratorDriver.RemoveGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) +M:Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalText(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.AdditionalText) +M:Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) +M:Microsoft.CodeAnalysis.GeneratorDriver.ReplaceGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) +M:Microsoft.CodeAnalysis.GeneratorDriver.RunGenerators(Microsoft.CodeAnalysis.Compilation,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.GeneratorDriver.RunGeneratorsAndUpdateCompilation(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Compilation@,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic}@,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedAnalyzerConfigOptions(Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) +M:Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedParseOptions(Microsoft.CodeAnalysis.ParseOptions) +M:Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind) +M:Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind,System.Boolean) +M:Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_Diagnostics +M:Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_GeneratedTrees +M:Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_Results +M:Microsoft.CodeAnalysis.GeneratorDriverTimingInfo.get_ElapsedTime +M:Microsoft.CodeAnalysis.GeneratorDriverTimingInfo.get_GeneratorTimes +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.AddSource(System.String,System.String) +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_AdditionalFiles +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_AnalyzerConfigOptions +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_CancellationToken +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_Compilation +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_ParseOptions +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_SyntaxContextReceiver +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_SyntaxReceiver +M:Microsoft.CodeAnalysis.GeneratorExecutionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.GeneratorExtensions.AsSourceGenerator(Microsoft.CodeAnalysis.IIncrementalGenerator) +M:Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(Microsoft.CodeAnalysis.ISourceGenerator) +M:Microsoft.CodeAnalysis.GeneratorInitializationContext.get_CancellationToken +M:Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForPostInitialization(System.Action{Microsoft.CodeAnalysis.GeneratorPostInitializationContext}) +M:Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxContextReceiverCreator) +M:Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxReceiverCreator) +M:Microsoft.CodeAnalysis.GeneratorPostInitializationContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.GeneratorPostInitializationContext.AddSource(System.String,System.String) +M:Microsoft.CodeAnalysis.GeneratorPostInitializationContext.get_CancellationToken +M:Microsoft.CodeAnalysis.GeneratorRunResult.get_Diagnostics +M:Microsoft.CodeAnalysis.GeneratorRunResult.get_Exception +M:Microsoft.CodeAnalysis.GeneratorRunResult.get_GeneratedSources +M:Microsoft.CodeAnalysis.GeneratorRunResult.get_Generator +M:Microsoft.CodeAnalysis.GeneratorRunResult.get_TrackedOutputSteps +M:Microsoft.CodeAnalysis.GeneratorRunResult.get_TrackedSteps +M:Microsoft.CodeAnalysis.GeneratorSyntaxContext.get_Node +M:Microsoft.CodeAnalysis.GeneratorSyntaxContext.get_SemanticModel +M:Microsoft.CodeAnalysis.GeneratorTimingInfo.get_ElapsedTime +M:Microsoft.CodeAnalysis.GeneratorTimingInfo.get_Generator +M:Microsoft.CodeAnalysis.IAliasSymbol.get_Target +M:Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader.AddDependencyLocation(System.String) +M:Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader.LoadFromPath(System.String) +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.Equals(Microsoft.CodeAnalysis.IArrayTypeSymbol) +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_CustomModifiers +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_ElementNullableAnnotation +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_ElementType +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_IsSZArray +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_LowerBounds +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_Rank +M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_Sizes +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_GlobalNamespace +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_Identity +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_IsInteractive +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_MightContainExtensionMethods +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_Modules +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_NamespaceNames +M:Microsoft.CodeAnalysis.IAssemblySymbol.get_TypeNames +M:Microsoft.CodeAnalysis.IAssemblySymbol.GetForwardedTypes +M:Microsoft.CodeAnalysis.IAssemblySymbol.GetMetadata +M:Microsoft.CodeAnalysis.IAssemblySymbol.GetTypeByMetadataName(System.String) +M:Microsoft.CodeAnalysis.IAssemblySymbol.GivesAccessTo(Microsoft.CodeAnalysis.IAssemblySymbol) +M:Microsoft.CodeAnalysis.IAssemblySymbol.ResolveForwardedType(System.String) +M:Microsoft.CodeAnalysis.ICompilationUnitSyntax.get_EndOfFileToken +M:Microsoft.CodeAnalysis.IDiscardSymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.IDiscardSymbol.get_Type +M:Microsoft.CodeAnalysis.IErrorTypeSymbol.get_CandidateReason +M:Microsoft.CodeAnalysis.IErrorTypeSymbol.get_CandidateSymbols +M:Microsoft.CodeAnalysis.IEventSymbol.get_AddMethod +M:Microsoft.CodeAnalysis.IEventSymbol.get_ExplicitInterfaceImplementations +M:Microsoft.CodeAnalysis.IEventSymbol.get_IsWindowsRuntimeEvent +M:Microsoft.CodeAnalysis.IEventSymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.IEventSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.IEventSymbol.get_OverriddenEvent +M:Microsoft.CodeAnalysis.IEventSymbol.get_RaiseMethod +M:Microsoft.CodeAnalysis.IEventSymbol.get_RemoveMethod +M:Microsoft.CodeAnalysis.IEventSymbol.get_Type +M:Microsoft.CodeAnalysis.IFieldSymbol.get_AssociatedSymbol +M:Microsoft.CodeAnalysis.IFieldSymbol.get_ConstantValue +M:Microsoft.CodeAnalysis.IFieldSymbol.get_CorrespondingTupleField +M:Microsoft.CodeAnalysis.IFieldSymbol.get_CustomModifiers +M:Microsoft.CodeAnalysis.IFieldSymbol.get_FixedSize +M:Microsoft.CodeAnalysis.IFieldSymbol.get_HasConstantValue +M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsConst +M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsExplicitlyNamedTupleElement +M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsFixedSizeBuffer +M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsReadOnly +M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsRequired +M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsVolatile +M:Microsoft.CodeAnalysis.IFieldSymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.IFieldSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.IFieldSymbol.get_RefCustomModifiers +M:Microsoft.CodeAnalysis.IFieldSymbol.get_RefKind +M:Microsoft.CodeAnalysis.IFieldSymbol.get_Type +M:Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol.get_Signature +M:Microsoft.CodeAnalysis.IImportScope.get_Aliases +M:Microsoft.CodeAnalysis.IImportScope.get_ExternAliases +M:Microsoft.CodeAnalysis.IImportScope.get_Imports +M:Microsoft.CodeAnalysis.IImportScope.get_XmlNamespaces +M:Microsoft.CodeAnalysis.IIncrementalGenerator.Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext) +M:Microsoft.CodeAnalysis.ILabelSymbol.get_ContainingMethod +M:Microsoft.CodeAnalysis.ILocalSymbol.get_ConstantValue +M:Microsoft.CodeAnalysis.ILocalSymbol.get_HasConstantValue +M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsConst +M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsFixed +M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsForEach +M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsFunctionValue +M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsRef +M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsUsing +M:Microsoft.CodeAnalysis.ILocalSymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.ILocalSymbol.get_RefKind +M:Microsoft.CodeAnalysis.ILocalSymbol.get_ScopedKind +M:Microsoft.CodeAnalysis.ILocalSymbol.get_Type +M:Microsoft.CodeAnalysis.IMethodSymbol.Construct(Microsoft.CodeAnalysis.ITypeSymbol[]) +M:Microsoft.CodeAnalysis.IMethodSymbol.Construct(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.IMethodSymbol.get_Arity +M:Microsoft.CodeAnalysis.IMethodSymbol.get_AssociatedAnonymousDelegate +M:Microsoft.CodeAnalysis.IMethodSymbol.get_AssociatedSymbol +M:Microsoft.CodeAnalysis.IMethodSymbol.get_CallingConvention +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ConstructedFrom +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ExplicitInterfaceImplementations +M:Microsoft.CodeAnalysis.IMethodSymbol.get_HidesBaseMethodsByName +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsAsync +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsCheckedBuiltin +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsConditional +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsExtensionMethod +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsGenericMethod +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsInitOnly +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsPartialDefinition +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsReadOnly +M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsVararg +M:Microsoft.CodeAnalysis.IMethodSymbol.get_MethodImplementationFlags +M:Microsoft.CodeAnalysis.IMethodSymbol.get_MethodKind +M:Microsoft.CodeAnalysis.IMethodSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.IMethodSymbol.get_OverriddenMethod +M:Microsoft.CodeAnalysis.IMethodSymbol.get_Parameters +M:Microsoft.CodeAnalysis.IMethodSymbol.get_PartialDefinitionPart +M:Microsoft.CodeAnalysis.IMethodSymbol.get_PartialImplementationPart +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReceiverNullableAnnotation +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReceiverType +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReducedFrom +M:Microsoft.CodeAnalysis.IMethodSymbol.get_RefCustomModifiers +M:Microsoft.CodeAnalysis.IMethodSymbol.get_RefKind +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnNullableAnnotation +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsByRef +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsByRefReadonly +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsVoid +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnType +M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnTypeCustomModifiers +M:Microsoft.CodeAnalysis.IMethodSymbol.get_TypeArgumentNullableAnnotations +M:Microsoft.CodeAnalysis.IMethodSymbol.get_TypeArguments +M:Microsoft.CodeAnalysis.IMethodSymbol.get_TypeParameters +M:Microsoft.CodeAnalysis.IMethodSymbol.get_UnmanagedCallingConventionTypes +M:Microsoft.CodeAnalysis.IMethodSymbol.GetDllImportData +M:Microsoft.CodeAnalysis.IMethodSymbol.GetReturnTypeAttributes +M:Microsoft.CodeAnalysis.IMethodSymbol.GetTypeInferredDuringReduction(Microsoft.CodeAnalysis.ITypeParameterSymbol) +M:Microsoft.CodeAnalysis.IMethodSymbol.ReduceExtensionMethod(Microsoft.CodeAnalysis.ITypeSymbol) +M:Microsoft.CodeAnalysis.IModuleSymbol.get_GlobalNamespace +M:Microsoft.CodeAnalysis.IModuleSymbol.get_ReferencedAssemblies +M:Microsoft.CodeAnalysis.IModuleSymbol.get_ReferencedAssemblySymbols +M:Microsoft.CodeAnalysis.IModuleSymbol.GetMetadata +M:Microsoft.CodeAnalysis.IModuleSymbol.GetModuleNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +M:Microsoft.CodeAnalysis.ImportedNamespaceOrType.get_DeclaringSyntaxReference +M:Microsoft.CodeAnalysis.ImportedNamespaceOrType.get_NamespaceOrType +M:Microsoft.CodeAnalysis.ImportedXmlNamespace.get_DeclaringSyntaxReference +M:Microsoft.CodeAnalysis.ImportedXmlNamespace.get_XmlNamespace +M:Microsoft.CodeAnalysis.INamedTypeSymbol.Construct(Microsoft.CodeAnalysis.ITypeSymbol[]) +M:Microsoft.CodeAnalysis.INamedTypeSymbol.Construct(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) +M:Microsoft.CodeAnalysis.INamedTypeSymbol.ConstructUnboundGenericType +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_Arity +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_AssociatedSymbol +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_ConstructedFrom +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_Constructors +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_DelegateInvokeMethod +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_EnumUnderlyingType +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_InstanceConstructors +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsComImport +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsFileLocal +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsGenericType +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsImplicitClass +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsScriptClass +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsSerializable +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsUnboundGenericType +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_MemberNames +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_MightContainExtensionMethods +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_NativeIntegerUnderlyingType +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_StaticConstructors +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TupleElements +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TupleUnderlyingType +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeArgumentNullableAnnotations +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeArguments +M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeParameters +M:Microsoft.CodeAnalysis.INamedTypeSymbol.GetTypeArgumentCustomModifiers(System.Int32) +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.get_IsNamespace +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.get_IsType +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetMembers +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetMembers(System.String) +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers(System.String) +M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers(System.String,System.Int32) +M:Microsoft.CodeAnalysis.INamespaceSymbol.get_ConstituentNamespaces +M:Microsoft.CodeAnalysis.INamespaceSymbol.get_ContainingCompilation +M:Microsoft.CodeAnalysis.INamespaceSymbol.get_IsGlobalNamespace +M:Microsoft.CodeAnalysis.INamespaceSymbol.get_NamespaceKind +M:Microsoft.CodeAnalysis.INamespaceSymbol.GetMembers +M:Microsoft.CodeAnalysis.INamespaceSymbol.GetMembers(System.String) +M:Microsoft.CodeAnalysis.INamespaceSymbol.GetNamespaceMembers +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_AdditionalTextsProvider +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_AnalyzerConfigOptionsProvider +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_CompilationProvider +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_MetadataReferencesProvider +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_ParseOptionsProvider +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_SyntaxProvider +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterPostInitializationOutput(System.Action{Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext}) +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) +M:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(System.String,System.String) +M:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.get_CancellationToken +M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_ElapsedTime +M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Inputs +M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Name +M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Outputs +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Collect``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},Microsoft.CodeAnalysis.IncrementalValueProvider{``1}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},Microsoft.CodeAnalysis.IncrementalValueProvider{``1}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,``1}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,``1}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Generic.IEnumerable{``1}}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Immutable.ImmutableArray{``1}}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Generic.IEnumerable{``1}}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Immutable.ImmutableArray{``1}}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Where``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Boolean}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithTrackingName``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.String) +M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithTrackingName``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.String) +M:Microsoft.CodeAnalysis.IOperation.Accept(Microsoft.CodeAnalysis.Operations.OperationVisitor) +M:Microsoft.CodeAnalysis.IOperation.Accept``2(Microsoft.CodeAnalysis.Operations.OperationVisitor{``0,``1},``0) +M:Microsoft.CodeAnalysis.IOperation.get_ChildOperations +M:Microsoft.CodeAnalysis.IOperation.get_Children +M:Microsoft.CodeAnalysis.IOperation.get_ConstantValue +M:Microsoft.CodeAnalysis.IOperation.get_IsImplicit +M:Microsoft.CodeAnalysis.IOperation.get_Kind +M:Microsoft.CodeAnalysis.IOperation.get_Language +M:Microsoft.CodeAnalysis.IOperation.get_Parent +M:Microsoft.CodeAnalysis.IOperation.get_SemanticModel +M:Microsoft.CodeAnalysis.IOperation.get_Syntax +M:Microsoft.CodeAnalysis.IOperation.get_Type +M:Microsoft.CodeAnalysis.IOperation.OperationList.Any +M:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.get_Current +M:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.Reset +M:Microsoft.CodeAnalysis.IOperation.OperationList.First +M:Microsoft.CodeAnalysis.IOperation.OperationList.get_Count +M:Microsoft.CodeAnalysis.IOperation.OperationList.GetEnumerator +M:Microsoft.CodeAnalysis.IOperation.OperationList.Last +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reverse +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.get_Current +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.Reset +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.get_Count +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.GetEnumerator +M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.ToImmutableArray +M:Microsoft.CodeAnalysis.IOperation.OperationList.ToImmutableArray +M:Microsoft.CodeAnalysis.IParameterSymbol.get_CustomModifiers +M:Microsoft.CodeAnalysis.IParameterSymbol.get_ExplicitDefaultValue +M:Microsoft.CodeAnalysis.IParameterSymbol.get_HasExplicitDefaultValue +M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsDiscard +M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsOptional +M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsParams +M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsParamsArray +M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsParamsCollection +M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsThis +M:Microsoft.CodeAnalysis.IParameterSymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.IParameterSymbol.get_Ordinal +M:Microsoft.CodeAnalysis.IParameterSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.IParameterSymbol.get_RefCustomModifiers +M:Microsoft.CodeAnalysis.IParameterSymbol.get_RefKind +M:Microsoft.CodeAnalysis.IParameterSymbol.get_ScopedKind +M:Microsoft.CodeAnalysis.IParameterSymbol.get_Type +M:Microsoft.CodeAnalysis.IPointerTypeSymbol.get_CustomModifiers +M:Microsoft.CodeAnalysis.IPointerTypeSymbol.get_PointedAtType +M:Microsoft.CodeAnalysis.IPropertySymbol.get_ExplicitInterfaceImplementations +M:Microsoft.CodeAnalysis.IPropertySymbol.get_GetMethod +M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsIndexer +M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsPartialDefinition +M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsReadOnly +M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsRequired +M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsWithEvents +M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsWriteOnly +M:Microsoft.CodeAnalysis.IPropertySymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.IPropertySymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.IPropertySymbol.get_OverriddenProperty +M:Microsoft.CodeAnalysis.IPropertySymbol.get_Parameters +M:Microsoft.CodeAnalysis.IPropertySymbol.get_PartialDefinitionPart +M:Microsoft.CodeAnalysis.IPropertySymbol.get_PartialImplementationPart +M:Microsoft.CodeAnalysis.IPropertySymbol.get_RefCustomModifiers +M:Microsoft.CodeAnalysis.IPropertySymbol.get_RefKind +M:Microsoft.CodeAnalysis.IPropertySymbol.get_ReturnsByRef +M:Microsoft.CodeAnalysis.IPropertySymbol.get_ReturnsByRefReadonly +M:Microsoft.CodeAnalysis.IPropertySymbol.get_SetMethod +M:Microsoft.CodeAnalysis.IPropertySymbol.get_Type +M:Microsoft.CodeAnalysis.IPropertySymbol.get_TypeCustomModifiers +M:Microsoft.CodeAnalysis.ISkippedTokensTriviaSyntax.get_Tokens +M:Microsoft.CodeAnalysis.ISourceAssemblySymbol.get_Compilation +M:Microsoft.CodeAnalysis.ISourceGenerator.Execute(Microsoft.CodeAnalysis.GeneratorExecutionContext) +M:Microsoft.CodeAnalysis.ISourceGenerator.Initialize(Microsoft.CodeAnalysis.GeneratorInitializationContext) +M:Microsoft.CodeAnalysis.IStructuredTriviaSyntax.get_ParentTrivia +M:Microsoft.CodeAnalysis.ISymbol.Accept(Microsoft.CodeAnalysis.SymbolVisitor) +M:Microsoft.CodeAnalysis.ISymbol.Accept``1(Microsoft.CodeAnalysis.SymbolVisitor{``0}) +M:Microsoft.CodeAnalysis.ISymbol.Accept``2(Microsoft.CodeAnalysis.SymbolVisitor{``0,``1},``0) +M:Microsoft.CodeAnalysis.ISymbol.Equals(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolEqualityComparer) +M:Microsoft.CodeAnalysis.ISymbol.get_CanBeReferencedByName +M:Microsoft.CodeAnalysis.ISymbol.get_ContainingAssembly +M:Microsoft.CodeAnalysis.ISymbol.get_ContainingModule +M:Microsoft.CodeAnalysis.ISymbol.get_ContainingNamespace +M:Microsoft.CodeAnalysis.ISymbol.get_ContainingSymbol +M:Microsoft.CodeAnalysis.ISymbol.get_ContainingType +M:Microsoft.CodeAnalysis.ISymbol.get_DeclaredAccessibility +M:Microsoft.CodeAnalysis.ISymbol.get_DeclaringSyntaxReferences +M:Microsoft.CodeAnalysis.ISymbol.get_HasUnsupportedMetadata +M:Microsoft.CodeAnalysis.ISymbol.get_IsAbstract +M:Microsoft.CodeAnalysis.ISymbol.get_IsDefinition +M:Microsoft.CodeAnalysis.ISymbol.get_IsExtern +M:Microsoft.CodeAnalysis.ISymbol.get_IsImplicitlyDeclared +M:Microsoft.CodeAnalysis.ISymbol.get_IsOverride +M:Microsoft.CodeAnalysis.ISymbol.get_IsSealed +M:Microsoft.CodeAnalysis.ISymbol.get_IsStatic +M:Microsoft.CodeAnalysis.ISymbol.get_IsVirtual +M:Microsoft.CodeAnalysis.ISymbol.get_Kind +M:Microsoft.CodeAnalysis.ISymbol.get_Language +M:Microsoft.CodeAnalysis.ISymbol.get_Locations +M:Microsoft.CodeAnalysis.ISymbol.get_MetadataName +M:Microsoft.CodeAnalysis.ISymbol.get_MetadataToken +M:Microsoft.CodeAnalysis.ISymbol.get_Name +M:Microsoft.CodeAnalysis.ISymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.ISymbol.GetAttributes +M:Microsoft.CodeAnalysis.ISymbol.GetDocumentationCommentId +M:Microsoft.CodeAnalysis.ISymbol.GetDocumentationCommentXml(System.Globalization.CultureInfo,System.Boolean,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.ISymbol.ToDisplayParts(Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ISymbol.ToDisplayString(Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ISymbol.ToMinimalDisplayParts(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ISymbol.ToMinimalDisplayString(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ISymbolExtensions.GetConstructedReducedFrom(Microsoft.CodeAnalysis.IMethodSymbol) +M:Microsoft.CodeAnalysis.ISyntaxContextReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.GeneratorSyntaxContext) +M:Microsoft.CodeAnalysis.ISyntaxReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_AllowsRefLikeType +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ConstraintNullableAnnotations +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ConstraintTypes +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_DeclaringMethod +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_DeclaringType +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasConstructorConstraint +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasNotNullConstraint +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasReferenceTypeConstraint +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasUnmanagedTypeConstraint +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasValueTypeConstraint +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_Ordinal +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ReducedFrom +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ReferenceTypeConstraintNullableAnnotation +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_TypeParameterKind +M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_Variance +M:Microsoft.CodeAnalysis.ITypeSymbol.FindImplementationForInterfaceMember(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.ITypeSymbol.get_AllInterfaces +M:Microsoft.CodeAnalysis.ITypeSymbol.get_BaseType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_Interfaces +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsAnonymousType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsNativeIntegerType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsReadOnly +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsRecord +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsReferenceType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsRefLikeType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsTupleType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsUnmanagedType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsValueType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_NullableAnnotation +M:Microsoft.CodeAnalysis.ITypeSymbol.get_OriginalDefinition +M:Microsoft.CodeAnalysis.ITypeSymbol.get_SpecialType +M:Microsoft.CodeAnalysis.ITypeSymbol.get_TypeKind +M:Microsoft.CodeAnalysis.ITypeSymbol.ToDisplayParts(Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ITypeSymbol.ToDisplayString(Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ITypeSymbol.ToMinimalDisplayParts(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.NullableFlowState,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ITypeSymbol.ToMinimalDisplayString(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.NullableFlowState,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) +M:Microsoft.CodeAnalysis.ITypeSymbol.WithNullableAnnotation(Microsoft.CodeAnalysis.NullableAnnotation) +M:Microsoft.CodeAnalysis.LineMapping.#ctor(Microsoft.CodeAnalysis.Text.LinePositionSpan,System.Nullable{System.Int32},Microsoft.CodeAnalysis.FileLinePositionSpan) +M:Microsoft.CodeAnalysis.LineMapping.Equals(Microsoft.CodeAnalysis.LineMapping) +M:Microsoft.CodeAnalysis.LineMapping.Equals(System.Object) +M:Microsoft.CodeAnalysis.LineMapping.get_CharacterOffset +M:Microsoft.CodeAnalysis.LineMapping.get_IsHidden +M:Microsoft.CodeAnalysis.LineMapping.get_MappedSpan +M:Microsoft.CodeAnalysis.LineMapping.get_Span +M:Microsoft.CodeAnalysis.LineMapping.GetHashCode +M:Microsoft.CodeAnalysis.LineMapping.op_Equality(Microsoft.CodeAnalysis.LineMapping,Microsoft.CodeAnalysis.LineMapping) +M:Microsoft.CodeAnalysis.LineMapping.op_Inequality(Microsoft.CodeAnalysis.LineMapping,Microsoft.CodeAnalysis.LineMapping) +M:Microsoft.CodeAnalysis.LineMapping.ToString +M:Microsoft.CodeAnalysis.LocalizableResourceString.#ctor(System.String,System.Resources.ResourceManager,System.Type) +M:Microsoft.CodeAnalysis.LocalizableResourceString.#ctor(System.String,System.Resources.ResourceManager,System.Type,System.String[]) +M:Microsoft.CodeAnalysis.LocalizableResourceString.AreEqual(System.Object) +M:Microsoft.CodeAnalysis.LocalizableResourceString.GetHash +M:Microsoft.CodeAnalysis.LocalizableResourceString.GetText(System.IFormatProvider) +M:Microsoft.CodeAnalysis.LocalizableString.#ctor +M:Microsoft.CodeAnalysis.LocalizableString.add_OnException(System.EventHandler{System.Exception}) +M:Microsoft.CodeAnalysis.LocalizableString.AreEqual(System.Object) +M:Microsoft.CodeAnalysis.LocalizableString.Equals(Microsoft.CodeAnalysis.LocalizableString) +M:Microsoft.CodeAnalysis.LocalizableString.Equals(System.Object) +M:Microsoft.CodeAnalysis.LocalizableString.GetHash +M:Microsoft.CodeAnalysis.LocalizableString.GetHashCode +M:Microsoft.CodeAnalysis.LocalizableString.GetText(System.IFormatProvider) +M:Microsoft.CodeAnalysis.LocalizableString.op_Explicit(Microsoft.CodeAnalysis.LocalizableString)~System.String +M:Microsoft.CodeAnalysis.LocalizableString.op_Implicit(System.String)~Microsoft.CodeAnalysis.LocalizableString +M:Microsoft.CodeAnalysis.LocalizableString.remove_OnException(System.EventHandler{System.Exception}) +M:Microsoft.CodeAnalysis.LocalizableString.ToString +M:Microsoft.CodeAnalysis.LocalizableString.ToString(System.IFormatProvider) +M:Microsoft.CodeAnalysis.Location.Create(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Location.Create(System.String,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.Location.Create(System.String,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan,System.String,Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.Location.Equals(System.Object) +M:Microsoft.CodeAnalysis.Location.get_IsInMetadata +M:Microsoft.CodeAnalysis.Location.get_IsInSource +M:Microsoft.CodeAnalysis.Location.get_Kind +M:Microsoft.CodeAnalysis.Location.get_MetadataModule +M:Microsoft.CodeAnalysis.Location.get_None +M:Microsoft.CodeAnalysis.Location.get_SourceSpan +M:Microsoft.CodeAnalysis.Location.get_SourceTree +M:Microsoft.CodeAnalysis.Location.GetDebuggerDisplay +M:Microsoft.CodeAnalysis.Location.GetHashCode +M:Microsoft.CodeAnalysis.Location.GetLineSpan +M:Microsoft.CodeAnalysis.Location.GetMappedLineSpan +M:Microsoft.CodeAnalysis.Location.op_Equality(Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.Location) +M:Microsoft.CodeAnalysis.Location.op_Inequality(Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.Location) +M:Microsoft.CodeAnalysis.Location.ToString +M:Microsoft.CodeAnalysis.Metadata.CommonCopy +M:Microsoft.CodeAnalysis.Metadata.Copy +M:Microsoft.CodeAnalysis.Metadata.Dispose +M:Microsoft.CodeAnalysis.Metadata.get_Id +M:Microsoft.CodeAnalysis.Metadata.get_Kind +M:Microsoft.CodeAnalysis.MetadataReference.#ctor(Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.MetadataReference.CreateFromAssembly(System.Reflection.Assembly) +M:Microsoft.CodeAnalysis.MetadataReference.CreateFromAssembly(System.Reflection.Assembly,Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider) +M:Microsoft.CodeAnalysis.MetadataReference.CreateFromImage(System.Collections.Generic.IEnumerable{System.Byte},Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider,System.String) +M:Microsoft.CodeAnalysis.MetadataReference.CreateFromImage(System.Collections.Immutable.ImmutableArray{System.Byte},Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider,System.String) +M:Microsoft.CodeAnalysis.MetadataReference.CreateFromStream(System.IO.Stream,Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider,System.String) +M:Microsoft.CodeAnalysis.MetadataReference.get_Display +M:Microsoft.CodeAnalysis.MetadataReference.get_Properties +M:Microsoft.CodeAnalysis.MetadataReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.MetadataReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.MetadataReference.WithEmbedInteropTypes(System.Boolean) +M:Microsoft.CodeAnalysis.MetadataReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.#ctor(Microsoft.CodeAnalysis.MetadataImageKind,System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.Equals(Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.Equals(System.Object) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Aliases +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Assembly +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_EmbedInteropTypes +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_GlobalAlias +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Kind +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Module +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.GetHashCode +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.op_Equality(Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.op_Inequality(Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.MetadataReferenceProperties.WithEmbedInteropTypes(System.Boolean) +M:Microsoft.CodeAnalysis.MetadataReferenceResolver.#ctor +M:Microsoft.CodeAnalysis.MetadataReferenceResolver.Equals(System.Object) +M:Microsoft.CodeAnalysis.MetadataReferenceResolver.get_ResolveMissingAssemblies +M:Microsoft.CodeAnalysis.MetadataReferenceResolver.GetHashCode +M:Microsoft.CodeAnalysis.MetadataReferenceResolver.ResolveMissingAssembly(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.AssemblyIdentity) +M:Microsoft.CodeAnalysis.MetadataReferenceResolver.ResolveReference(System.String,System.String,Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.ModelExtensions.GetAliasInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.ModelExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.ModelExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeAliasInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeTypeInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.ModelExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.ModelExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.ModuleMetadata.CommonCopy +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromFile(System.String) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromImage(System.Collections.Generic.IEnumerable{System.Byte}) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromImage(System.Collections.Immutable.ImmutableArray{System.Byte}) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromImage(System.IntPtr,System.Int32) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromMetadata(System.IntPtr,System.Int32) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromMetadata(System.IntPtr,System.Int32,System.Action) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromStream(System.IO.Stream,System.Boolean) +M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromStream(System.IO.Stream,System.Reflection.PortableExecutable.PEStreamOptions) +M:Microsoft.CodeAnalysis.ModuleMetadata.Dispose +M:Microsoft.CodeAnalysis.ModuleMetadata.get_IsDisposed +M:Microsoft.CodeAnalysis.ModuleMetadata.get_Kind +M:Microsoft.CodeAnalysis.ModuleMetadata.get_Name +M:Microsoft.CodeAnalysis.ModuleMetadata.GetMetadataReader +M:Microsoft.CodeAnalysis.ModuleMetadata.GetModuleNames +M:Microsoft.CodeAnalysis.ModuleMetadata.GetModuleVersionId +M:Microsoft.CodeAnalysis.ModuleMetadata.GetReference(Microsoft.CodeAnalysis.DocumentationProvider,System.String,System.String) +M:Microsoft.CodeAnalysis.NullabilityInfo.Equals(Microsoft.CodeAnalysis.NullabilityInfo) +M:Microsoft.CodeAnalysis.NullabilityInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.NullabilityInfo.get_Annotation +M:Microsoft.CodeAnalysis.NullabilityInfo.get_FlowState +M:Microsoft.CodeAnalysis.NullabilityInfo.GetHashCode +M:Microsoft.CodeAnalysis.NullableContextExtensions.AnnotationsEnabled(Microsoft.CodeAnalysis.NullableContext) +M:Microsoft.CodeAnalysis.NullableContextExtensions.AnnotationsInherited(Microsoft.CodeAnalysis.NullableContext) +M:Microsoft.CodeAnalysis.NullableContextExtensions.WarningsEnabled(Microsoft.CodeAnalysis.NullableContext) +M:Microsoft.CodeAnalysis.NullableContextExtensions.WarningsInherited(Microsoft.CodeAnalysis.NullableContext) +M:Microsoft.CodeAnalysis.NullableContextOptionsExtensions.AnnotationsEnabled(Microsoft.CodeAnalysis.NullableContextOptions) +M:Microsoft.CodeAnalysis.NullableContextOptionsExtensions.WarningsEnabled(Microsoft.CodeAnalysis.NullableContextOptions) +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_Exists +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsIdentity +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsImplicit +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsNullable +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsNumeric +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsReference +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsUserDefined +M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_MethodSymbol +M:Microsoft.CodeAnalysis.Operations.IAddressOfOperation.get_Reference +M:Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation.get_Symbol +M:Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation.get_Initializers +M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_ArgumentKind +M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_InConversion +M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_OutConversion +M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_Parameter +M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IArrayCreationOperation.get_DimensionSizes +M:Microsoft.CodeAnalysis.Operations.IArrayCreationOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation.get_ArrayReference +M:Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation.get_Indices +M:Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation.get_ElementValues +M:Microsoft.CodeAnalysis.Operations.IAssignmentOperation.get_Target +M:Microsoft.CodeAnalysis.Operations.IAssignmentOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IAttributeOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IAwaitOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsChecked +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsCompareText +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsLifted +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_LeftOperand +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_OperatorKind +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_OperatorMethod +M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_RightOperand +M:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_LeftPattern +M:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_OperatorKind +M:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_RightPattern +M:Microsoft.CodeAnalysis.Operations.IBlockOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.IBlockOperation.get_Operations +M:Microsoft.CodeAnalysis.Operations.IBranchOperation.get_BranchKind +M:Microsoft.CodeAnalysis.Operations.IBranchOperation.get_Target +M:Microsoft.CodeAnalysis.Operations.ICaseClauseOperation.get_CaseKind +M:Microsoft.CodeAnalysis.Operations.ICaseClauseOperation.get_Label +M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_ExceptionDeclarationOrExpression +M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_ExceptionType +M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Filter +M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Handler +M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_ValueConversion +M:Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_WhenNull +M:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_AddMethod +M:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_IsDynamic +M:Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation.get_ConstructMethod +M:Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation.get_Elements +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_InConversion +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_IsChecked +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_IsLifted +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OperatorKind +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OperatorMethod +M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OutConversion +M:Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation.get_WhenNotNull +M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_Condition +M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_IsRef +M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_WhenFalse +M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_WhenTrue +M:Microsoft.CodeAnalysis.Operations.IConstantPatternOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_Conversion +M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_IsChecked +M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_IsTryCast +M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_Operand +M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_OperatorMethod +M:Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation.get_Expression +M:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_DeclaredSymbol +M:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_MatchedType +M:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_MatchesNull +M:Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation.get_Target +M:Microsoft.CodeAnalysis.Operations.IDiscardOperation.get_DiscardSymbol +M:Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_ContainingType +M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_Instance +M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_MemberName +M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_TypeArguments +M:Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_Adds +M:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_EventReference +M:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_HandlerValue +M:Microsoft.CodeAnalysis.Operations.IEventReferenceOperation.get_Event +M:Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation.get_InitializedFields +M:Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation.get_Field +M:Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation.get_IsDeclaration +M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_Collection +M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_IsAsynchronous +M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_LoopControlVariable +M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_NextVariables +M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_AtLoopBottom +M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_Before +M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_Condition +M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_ConditionLocals +M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_InitialValue +M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_IsChecked +M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_LimitValue +M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_LoopControlVariable +M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_NextVariables +M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_StepValue +M:Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation.get_Target +M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_Argument +M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_IndexerSymbol +M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_Instance +M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_LengthSymbol +M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsChecked +M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsLifted +M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsPostfix +M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_OperatorMethod +M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_Target +M:Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation.get_Argument +M:Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation.get_Instance +M:Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation.get_ReferenceKind +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation.get_Left +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation.get_Right +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation.get_AppendCall +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation.get_ArgumentIndex +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation.get_PlaceholderKind +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_Content +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerAppendCallsReturnBool +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerCreation +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerCreationHasSuccessParameter +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation.get_Parts +M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation.get_Text +M:Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_Alignment +M:Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_Expression +M:Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_FormatString +M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_Instance +M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_IsVirtual +M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_TargetMethod +M:Microsoft.CodeAnalysis.Operations.IIsPatternOperation.get_Pattern +M:Microsoft.CodeAnalysis.Operations.IIsPatternOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_IsNegated +M:Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_TypeOperand +M:Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_ValueOperand +M:Microsoft.CodeAnalysis.Operations.ILabeledOperation.get_Label +M:Microsoft.CodeAnalysis.Operations.ILabeledOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_DeclaredSymbol +M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_IndexerSymbol +M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_LengthSymbol +M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_Patterns +M:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_IgnoredBody +M:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_Symbol +M:Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation.get_IsDeclaration +M:Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation.get_Local +M:Microsoft.CodeAnalysis.Operations.ILockOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.ILockOperation.get_LockedValue +M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_ContinueLabel +M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_ExitLabel +M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_LoopKind +M:Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation.get_InitializedMember +M:Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_Instance +M:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_Member +M:Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation.get_BlockBody +M:Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation.get_ExpressionBody +M:Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation.get_IsVirtual +M:Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation.get_Method +M:Microsoft.CodeAnalysis.Operations.INameOfOperation.get_Argument +M:Microsoft.CodeAnalysis.Operations.INegatedPatternOperation.get_Pattern +M:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Constructor +M:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation.get_Initializers +M:Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation.get_Parameter +M:Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation.get_Parameter +M:Microsoft.CodeAnalysis.Operations.IParenthesizedOperation.get_Operand +M:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Guard +M:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Label +M:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Pattern +M:Microsoft.CodeAnalysis.Operations.IPatternOperation.get_InputType +M:Microsoft.CodeAnalysis.Operations.IPatternOperation.get_NarrowedType +M:Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation.get_InitializedProperties +M:Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation.get_Property +M:Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation.get_Member +M:Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation.get_Pattern +M:Microsoft.CodeAnalysis.Operations.IRaiseEventOperation.get_Arguments +M:Microsoft.CodeAnalysis.Operations.IRaiseEventOperation.get_EventReference +M:Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation.get_MaximumValue +M:Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation.get_MinimumValue +M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_IsLifted +M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_LeftOperand +M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_Method +M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_RightOperand +M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeclaredSymbol +M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeconstructionSubpatterns +M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeconstructSymbol +M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_MatchedType +M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_PropertySubpatterns +M:Microsoft.CodeAnalysis.Operations.IReDimClauseOperation.get_DimensionSizes +M:Microsoft.CodeAnalysis.Operations.IReDimClauseOperation.get_Operand +M:Microsoft.CodeAnalysis.Operations.IReDimOperation.get_Clauses +M:Microsoft.CodeAnalysis.Operations.IReDimOperation.get_Preserve +M:Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation.get_Relation +M:Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation.get_OperatorKind +M:Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IReturnOperation.get_ReturnedValue +M:Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation.get_IsRef +M:Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.ISizeOfOperation.get_TypeOperand +M:Microsoft.CodeAnalysis.Operations.ISlicePatternOperation.get_Pattern +M:Microsoft.CodeAnalysis.Operations.ISlicePatternOperation.get_SliceSymbol +M:Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_ElementConversion +M:Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_ElementType +M:Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_Operand +M:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Clauses +M:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Guard +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Pattern +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_Arms +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_IsExhaustive +M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Cases +M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_ExitLabel +M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IThrowOperation.get_Exception +M:Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation.get_Operation +M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_Catches +M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_ExitLabel +M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_Finally +M:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_LeftOperand +M:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_OperatorKind +M:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_RightOperand +M:Microsoft.CodeAnalysis.Operations.ITupleOperation.get_Elements +M:Microsoft.CodeAnalysis.Operations.ITupleOperation.get_NaturalType +M:Microsoft.CodeAnalysis.Operations.ITypeOfOperation.get_TypeOperand +M:Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.ITypePatternOperation.get_MatchedType +M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_ConstrainedToType +M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_IsChecked +M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_IsLifted +M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_Operand +M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_OperatorKind +M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_OperatorMethod +M:Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation.get_DeclarationGroup +M:Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation.get_IsAsynchronous +M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Body +M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_IsAsynchronous +M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Locals +M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Resources +M:Microsoft.CodeAnalysis.Operations.IUtf8StringOperation.get_Value +M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation.get_Declarations +M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_Declarators +M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_IgnoredDimensions +M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_IgnoredArguments +M:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_Symbol +M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_Condition +M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_ConditionIsTop +M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_ConditionIsUntil +M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_IgnoredCondition +M:Microsoft.CodeAnalysis.Operations.IWithOperation.get_CloneMethod +M:Microsoft.CodeAnalysis.Operations.IWithOperation.get_Initializer +M:Microsoft.CodeAnalysis.Operations.IWithOperation.get_Operand +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.Descendants(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.DescendantsAndSelf(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,System.Int32) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,System.Int32) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,System.Int32) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,System.Int32) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,System.Int32) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,System.Int32) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetCorrespondingOperation(Microsoft.CodeAnalysis.Operations.IBranchOperation) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetDeclaredVariables(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetDeclaredVariables(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetFunctionPointerSignature(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.#ctor +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.DefaultVisit(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.Visit(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAddressOf(Microsoft.CodeAnalysis.Operations.IAddressOfOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAnonymousFunction(Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAnonymousObjectCreation(Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArgument(Microsoft.CodeAnalysis.Operations.IArgumentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayCreation(Microsoft.CodeAnalysis.Operations.IArrayCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayElementReference(Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayInitializer(Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAttribute(Microsoft.CodeAnalysis.Operations.IAttributeOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAwait(Microsoft.CodeAnalysis.Operations.IAwaitOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBinaryOperator(Microsoft.CodeAnalysis.Operations.IBinaryOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBlock(Microsoft.CodeAnalysis.Operations.IBlockOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBranch(Microsoft.CodeAnalysis.Operations.IBranchOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCatchClause(Microsoft.CodeAnalysis.Operations.ICatchClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCaughtException(Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCoalesce(Microsoft.CodeAnalysis.Operations.ICoalesceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCoalesceAssignment(Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCollectionElementInitializer(Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCollectionExpression(Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCompoundAssignment(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditional(Microsoft.CodeAnalysis.Operations.IConditionalOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditionalAccess(Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditionalAccessInstance(Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.Operations.IConstantPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConstructorBodyOperation(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeconstructionAssignment(Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDefaultCaseClause(Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDefaultValue(Microsoft.CodeAnalysis.Operations.IDefaultValueOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDelegateCreation(Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDiscardOperation(Microsoft.CodeAnalysis.Operations.IDiscardOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicIndexerAccess(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicInvocation(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicMemberReference(Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicObjectCreation(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEmpty(Microsoft.CodeAnalysis.Operations.IEmptyOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEnd(Microsoft.CodeAnalysis.Operations.IEndOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEventAssignment(Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEventReference(Microsoft.CodeAnalysis.Operations.IEventReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFieldInitializer(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFieldReference(Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowAnonymousFunction(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowCapture(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowCaptureReference(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForEachLoop(Microsoft.CodeAnalysis.Operations.IForEachLoopOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForLoop(Microsoft.CodeAnalysis.Operations.IForLoopOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForToLoop(Microsoft.CodeAnalysis.Operations.IForToLoopOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFunctionPointerInvocation(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitImplicitIndexerReference(Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIncrementOrDecrement(Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInlineArrayAccess(Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInstanceReference(Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedString(Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringAddition(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringAppend(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringHandlerArgumentPlaceholder(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringHandlerCreation(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolation(Microsoft.CodeAnalysis.Operations.IInterpolationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInvalid(Microsoft.CodeAnalysis.Operations.IInvalidOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInvocation(Microsoft.CodeAnalysis.Operations.IInvocationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsNull(Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsPattern(Microsoft.CodeAnalysis.Operations.IIsPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsType(Microsoft.CodeAnalysis.Operations.IIsTypeOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLabeled(Microsoft.CodeAnalysis.Operations.ILabeledOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitListPattern(Microsoft.CodeAnalysis.Operations.IListPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLiteral(Microsoft.CodeAnalysis.Operations.ILiteralOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLocalFunction(Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLocalReference(Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLock(Microsoft.CodeAnalysis.Operations.ILockOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMemberInitializer(Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMethodBodyOperation(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMethodReference(Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitNameOf(Microsoft.CodeAnalysis.Operations.INameOfOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitNegatedPattern(Microsoft.CodeAnalysis.Operations.INegatedPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitObjectCreation(Microsoft.CodeAnalysis.Operations.IObjectCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitObjectOrCollectionInitializer(Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitOmittedArgument(Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParameterInitializer(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParameterReference(Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParenthesized(Microsoft.CodeAnalysis.Operations.IParenthesizedOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPatternCaseClause(Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertyInitializer(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertyReference(Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertySubpattern(Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRaiseEvent(Microsoft.CodeAnalysis.Operations.IRaiseEventOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRangeCaseClause(Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRangeOperation(Microsoft.CodeAnalysis.Operations.IRangeOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReDim(Microsoft.CodeAnalysis.Operations.IReDimOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReDimClause(Microsoft.CodeAnalysis.Operations.IReDimClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRelationalCaseClause(Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReturn(Microsoft.CodeAnalysis.Operations.IReturnOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSimpleAssignment(Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSingleValueCaseClause(Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSizeOf(Microsoft.CodeAnalysis.Operations.ISizeOfOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.Operations.ISlicePatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSpread(Microsoft.CodeAnalysis.Operations.ISpreadOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitStaticLocalInitializationSemaphore(Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitStop(Microsoft.CodeAnalysis.Operations.IStopOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitch(Microsoft.CodeAnalysis.Operations.ISwitchOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchCase(Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitThrow(Microsoft.CodeAnalysis.Operations.IThrowOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTranslatedQuery(Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTry(Microsoft.CodeAnalysis.Operations.ITryOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTuple(Microsoft.CodeAnalysis.Operations.ITupleOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTupleBinaryOperator(Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypeOf(Microsoft.CodeAnalysis.Operations.ITypeOfOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypeParameterObjectCreation(Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypePattern(Microsoft.CodeAnalysis.Operations.ITypePatternOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUnaryOperator(Microsoft.CodeAnalysis.Operations.IUnaryOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUsing(Microsoft.CodeAnalysis.Operations.IUsingOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUsingDeclaration(Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUtf8String(Microsoft.CodeAnalysis.Operations.IUtf8StringOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclarationGroup(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitWhileLoop(Microsoft.CodeAnalysis.Operations.IWhileLoopOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitWith(Microsoft.CodeAnalysis.Operations.IWithOperation) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.#ctor +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.DefaultVisit(Microsoft.CodeAnalysis.IOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.Visit(Microsoft.CodeAnalysis.IOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAddressOf(Microsoft.CodeAnalysis.Operations.IAddressOfOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAnonymousFunction(Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAnonymousObjectCreation(Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArgument(Microsoft.CodeAnalysis.Operations.IArgumentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayCreation(Microsoft.CodeAnalysis.Operations.IArrayCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayElementReference(Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayInitializer(Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAttribute(Microsoft.CodeAnalysis.Operations.IAttributeOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAwait(Microsoft.CodeAnalysis.Operations.IAwaitOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBinaryOperator(Microsoft.CodeAnalysis.Operations.IBinaryOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBinaryPattern(Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBlock(Microsoft.CodeAnalysis.Operations.IBlockOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBranch(Microsoft.CodeAnalysis.Operations.IBranchOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCatchClause(Microsoft.CodeAnalysis.Operations.ICatchClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCaughtException(Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCoalesce(Microsoft.CodeAnalysis.Operations.ICoalesceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCoalesceAssignment(Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCollectionElementInitializer(Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCollectionExpression(Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCompoundAssignment(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditional(Microsoft.CodeAnalysis.Operations.IConditionalOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditionalAccess(Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditionalAccessInstance(Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConstantPattern(Microsoft.CodeAnalysis.Operations.IConstantPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConstructorBodyOperation(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeclarationExpression(Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeclarationPattern(Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeconstructionAssignment(Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDefaultCaseClause(Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDefaultValue(Microsoft.CodeAnalysis.Operations.IDefaultValueOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDelegateCreation(Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDiscardOperation(Microsoft.CodeAnalysis.Operations.IDiscardOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDiscardPattern(Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicIndexerAccess(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicInvocation(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicMemberReference(Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicObjectCreation(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEmpty(Microsoft.CodeAnalysis.Operations.IEmptyOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEnd(Microsoft.CodeAnalysis.Operations.IEndOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEventAssignment(Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEventReference(Microsoft.CodeAnalysis.Operations.IEventReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitExpressionStatement(Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFieldInitializer(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFieldReference(Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowAnonymousFunction(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowCapture(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowCaptureReference(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForEachLoop(Microsoft.CodeAnalysis.Operations.IForEachLoopOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForLoop(Microsoft.CodeAnalysis.Operations.IForLoopOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForToLoop(Microsoft.CodeAnalysis.Operations.IForToLoopOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFunctionPointerInvocation(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitImplicitIndexerReference(Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIncrementOrDecrement(Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInlineArrayAccess(Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInstanceReference(Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedString(Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringAddition(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringAppend(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringHandlerArgumentPlaceholder(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringHandlerCreation(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringText(Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolation(Microsoft.CodeAnalysis.Operations.IInterpolationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInvalid(Microsoft.CodeAnalysis.Operations.IInvalidOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInvocation(Microsoft.CodeAnalysis.Operations.IInvocationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsNull(Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsPattern(Microsoft.CodeAnalysis.Operations.IIsPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsType(Microsoft.CodeAnalysis.Operations.IIsTypeOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLabeled(Microsoft.CodeAnalysis.Operations.ILabeledOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitListPattern(Microsoft.CodeAnalysis.Operations.IListPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLiteral(Microsoft.CodeAnalysis.Operations.ILiteralOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLocalFunction(Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLocalReference(Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLock(Microsoft.CodeAnalysis.Operations.ILockOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMemberInitializer(Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMethodBodyOperation(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMethodReference(Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitNameOf(Microsoft.CodeAnalysis.Operations.INameOfOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitNegatedPattern(Microsoft.CodeAnalysis.Operations.INegatedPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitObjectCreation(Microsoft.CodeAnalysis.Operations.IObjectCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitObjectOrCollectionInitializer(Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitOmittedArgument(Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParameterInitializer(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParameterReference(Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParenthesized(Microsoft.CodeAnalysis.Operations.IParenthesizedOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPatternCaseClause(Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertyInitializer(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertyReference(Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertySubpattern(Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRaiseEvent(Microsoft.CodeAnalysis.Operations.IRaiseEventOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRangeCaseClause(Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRangeOperation(Microsoft.CodeAnalysis.Operations.IRangeOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRecursivePattern(Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReDim(Microsoft.CodeAnalysis.Operations.IReDimOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReDimClause(Microsoft.CodeAnalysis.Operations.IReDimClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRelationalCaseClause(Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRelationalPattern(Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReturn(Microsoft.CodeAnalysis.Operations.IReturnOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSimpleAssignment(Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSingleValueCaseClause(Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSizeOf(Microsoft.CodeAnalysis.Operations.ISizeOfOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSlicePattern(Microsoft.CodeAnalysis.Operations.ISlicePatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSpread(Microsoft.CodeAnalysis.Operations.ISpreadOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitStaticLocalInitializationSemaphore(Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitStop(Microsoft.CodeAnalysis.Operations.IStopOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitch(Microsoft.CodeAnalysis.Operations.ISwitchOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchCase(Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchExpression(Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitThrow(Microsoft.CodeAnalysis.Operations.IThrowOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTranslatedQuery(Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTry(Microsoft.CodeAnalysis.Operations.ITryOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTuple(Microsoft.CodeAnalysis.Operations.ITupleOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTupleBinaryOperator(Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypeOf(Microsoft.CodeAnalysis.Operations.ITypeOfOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypeParameterObjectCreation(Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypePattern(Microsoft.CodeAnalysis.Operations.ITypePatternOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUnaryOperator(Microsoft.CodeAnalysis.Operations.IUnaryOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUsing(Microsoft.CodeAnalysis.Operations.IUsingOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUsingDeclaration(Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUtf8String(Microsoft.CodeAnalysis.Operations.IUtf8StringOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclaration(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclarationGroup(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclarator(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitWhileLoop(Microsoft.CodeAnalysis.Operations.IWhileLoopOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitWith(Microsoft.CodeAnalysis.Operations.IWithOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationWalker.#ctor +M:Microsoft.CodeAnalysis.Operations.OperationWalker.DefaultVisit(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Operations.OperationWalker.Visit(Microsoft.CodeAnalysis.IOperation) +M:Microsoft.CodeAnalysis.Operations.OperationWalker`1.#ctor +M:Microsoft.CodeAnalysis.Operations.OperationWalker`1.DefaultVisit(Microsoft.CodeAnalysis.IOperation,`0) +M:Microsoft.CodeAnalysis.Operations.OperationWalker`1.Visit(Microsoft.CodeAnalysis.IOperation,`0) +M:Microsoft.CodeAnalysis.Optional`1.#ctor(`0) +M:Microsoft.CodeAnalysis.Optional`1.get_HasValue +M:Microsoft.CodeAnalysis.Optional`1.get_Value +M:Microsoft.CodeAnalysis.Optional`1.op_Implicit(`0)~Microsoft.CodeAnalysis.Optional{`0} +M:Microsoft.CodeAnalysis.Optional`1.ToString +M:Microsoft.CodeAnalysis.ParseOptions.CommonWithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +M:Microsoft.CodeAnalysis.ParseOptions.CommonWithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +M:Microsoft.CodeAnalysis.ParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind) +M:Microsoft.CodeAnalysis.ParseOptions.Equals(System.Object) +M:Microsoft.CodeAnalysis.ParseOptions.EqualsHelper(Microsoft.CodeAnalysis.ParseOptions) +M:Microsoft.CodeAnalysis.ParseOptions.get_DocumentationMode +M:Microsoft.CodeAnalysis.ParseOptions.get_Errors +M:Microsoft.CodeAnalysis.ParseOptions.get_Features +M:Microsoft.CodeAnalysis.ParseOptions.get_Kind +M:Microsoft.CodeAnalysis.ParseOptions.get_Language +M:Microsoft.CodeAnalysis.ParseOptions.get_PreprocessorSymbolNames +M:Microsoft.CodeAnalysis.ParseOptions.get_SpecifiedKind +M:Microsoft.CodeAnalysis.ParseOptions.GetHashCode +M:Microsoft.CodeAnalysis.ParseOptions.GetHashCodeHelper +M:Microsoft.CodeAnalysis.ParseOptions.op_Equality(Microsoft.CodeAnalysis.ParseOptions,Microsoft.CodeAnalysis.ParseOptions) +M:Microsoft.CodeAnalysis.ParseOptions.op_Inequality(Microsoft.CodeAnalysis.ParseOptions,Microsoft.CodeAnalysis.ParseOptions) +M:Microsoft.CodeAnalysis.ParseOptions.set_DocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +M:Microsoft.CodeAnalysis.ParseOptions.set_Kind(Microsoft.CodeAnalysis.SourceCodeKind) +M:Microsoft.CodeAnalysis.ParseOptions.set_SpecifiedKind(Microsoft.CodeAnalysis.SourceCodeKind) +M:Microsoft.CodeAnalysis.ParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) +M:Microsoft.CodeAnalysis.ParseOptions.WithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +M:Microsoft.CodeAnalysis.ParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind) +M:Microsoft.CodeAnalysis.PortableExecutableReference.#ctor(Microsoft.CodeAnalysis.MetadataReferenceProperties,System.String,Microsoft.CodeAnalysis.DocumentationProvider) +M:Microsoft.CodeAnalysis.PortableExecutableReference.CreateDocumentationProvider +M:Microsoft.CodeAnalysis.PortableExecutableReference.get_Display +M:Microsoft.CodeAnalysis.PortableExecutableReference.get_FilePath +M:Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadata +M:Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataId +M:Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataImpl +M:Microsoft.CodeAnalysis.PortableExecutableReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.PortableExecutableReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) +M:Microsoft.CodeAnalysis.PortableExecutableReference.WithEmbedInteropTypes(System.Boolean) +M:Microsoft.CodeAnalysis.PortableExecutableReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.PortableExecutableReference.WithPropertiesImpl(Microsoft.CodeAnalysis.MetadataReferenceProperties) +M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.Equals(Microsoft.CodeAnalysis.PreprocessingSymbolInfo) +M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.get_IsDefined +M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.get_Symbol +M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.GetHashCode +M:Microsoft.CodeAnalysis.ResourceDescription.#ctor(System.String,System.Func{System.IO.Stream},System.Boolean) +M:Microsoft.CodeAnalysis.ResourceDescription.#ctor(System.String,System.String,System.Func{System.IO.Stream},System.Boolean) +M:Microsoft.CodeAnalysis.RuleSet.#ctor(System.String,Microsoft.CodeAnalysis.ReportDiagnostic,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RuleSetInclude}) +M:Microsoft.CodeAnalysis.RuleSet.get_FilePath +M:Microsoft.CodeAnalysis.RuleSet.get_GeneralDiagnosticOption +M:Microsoft.CodeAnalysis.RuleSet.get_Includes +M:Microsoft.CodeAnalysis.RuleSet.get_SpecificDiagnosticOptions +M:Microsoft.CodeAnalysis.RuleSet.GetDiagnosticOptionsFromRulesetFile(System.String,System.Collections.Generic.Dictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}@) +M:Microsoft.CodeAnalysis.RuleSet.GetEffectiveIncludesFromFile(System.String) +M:Microsoft.CodeAnalysis.RuleSet.LoadEffectiveRuleSetFromFile(System.String) +M:Microsoft.CodeAnalysis.RuleSet.WithEffectiveAction(Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.RuleSetInclude.#ctor(System.String,Microsoft.CodeAnalysis.ReportDiagnostic) +M:Microsoft.CodeAnalysis.RuleSetInclude.get_Action +M:Microsoft.CodeAnalysis.RuleSetInclude.get_IncludePath +M:Microsoft.CodeAnalysis.RuleSetInclude.LoadRuleSet(Microsoft.CodeAnalysis.RuleSet) +M:Microsoft.CodeAnalysis.SarifVersionFacts.TryParse(System.String,Microsoft.CodeAnalysis.SarifVersion@) +M:Microsoft.CodeAnalysis.ScriptCompilationInfo.get_GlobalsType +M:Microsoft.CodeAnalysis.ScriptCompilationInfo.get_PreviousScriptCompilation +M:Microsoft.CodeAnalysis.ScriptCompilationInfo.get_ReturnType +M:Microsoft.CodeAnalysis.ScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.Compilation) +M:Microsoft.CodeAnalysis.SemanticModel.#ctor +M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeControlFlowCore(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeControlFlowCore(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeDataFlowCore(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeDataFlowCore(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.get_Compilation +M:Microsoft.CodeAnalysis.SemanticModel.get_CompilationCore +M:Microsoft.CodeAnalysis.SemanticModel.get_IgnoresAccessibility +M:Microsoft.CodeAnalysis.SemanticModel.get_IsSpeculativeSemanticModel +M:Microsoft.CodeAnalysis.SemanticModel.get_Language +M:Microsoft.CodeAnalysis.SemanticModel.get_NullableAnalysisIsDisabled +M:Microsoft.CodeAnalysis.SemanticModel.get_OriginalPositionForSpeculation +M:Microsoft.CodeAnalysis.SemanticModel.get_ParentModel +M:Microsoft.CodeAnalysis.SemanticModel.get_ParentModelCore +M:Microsoft.CodeAnalysis.SemanticModel.get_RootCore +M:Microsoft.CodeAnalysis.SemanticModel.get_SyntaxTree +M:Microsoft.CodeAnalysis.SemanticModel.get_SyntaxTreeCore +M:Microsoft.CodeAnalysis.SemanticModel.GetAliasInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetConstantValue(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetConstantValueCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetDeclarationDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetDeclaredSymbolCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetDeclaredSymbolsCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetEnclosingSymbol(System.Int32,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetEnclosingSymbolCore(System.Int32,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetImportScopes(System.Int32,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetMemberGroupCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetMethodBodyDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetNullableContext(System.Int32) +M:Microsoft.CodeAnalysis.SemanticModel.GetOperation(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetOperationCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetPreprocessingSymbolInfo(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.GetPreprocessingSymbolInfoCore(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeAliasInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeSymbolInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeTypeInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) +M:Microsoft.CodeAnalysis.SemanticModel.GetSymbolInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetSyntaxDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.GetTopmostNodeForDiagnosticAnalysis(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SemanticModel.GetTypeInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SemanticModel.IsAccessible(System.Int32,Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SemanticModel.IsAccessibleCore(System.Int32,Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SemanticModel.IsEventUsableAsField(System.Int32,Microsoft.CodeAnalysis.IEventSymbol) +M:Microsoft.CodeAnalysis.SemanticModel.IsEventUsableAsFieldCore(System.Int32,Microsoft.CodeAnalysis.IEventSymbol) +M:Microsoft.CodeAnalysis.SemanticModel.LookupBaseMembers(System.Int32,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupBaseMembersCore(System.Int32,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupLabels(System.Int32,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupLabelsCore(System.Int32,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupNamespacesAndTypes(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupNamespacesAndTypesCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupStaticMembers(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupStaticMembersCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) +M:Microsoft.CodeAnalysis.SemanticModel.LookupSymbols(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.SemanticModel.LookupSymbolsCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList.Create``1(System.ReadOnlySpan{``0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Add(`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Any +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Contains(`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.Equals(System.Object) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.GetHashCode +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.Reset +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Equals(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Equals(System.Object) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.First +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.FirstOrDefault +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Count +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_FullSpan +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_SeparatorCount +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Span +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetEnumerator +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetHashCode +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetSeparator(System.Int32) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetSeparators +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetWithSeparators +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.IndexOf(`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.IndexOf(System.Func{`0,System.Boolean}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Insert(System.Int32,`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Last +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastIndexOf(`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastIndexOf(System.Func{`0,System.Boolean}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastOrDefault +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Equality(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0},Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Explicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode})~Microsoft.CodeAnalysis.SeparatedSyntaxList{`0} +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0})~Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode} +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Inequality(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0},Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Remove(`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.RemoveAt(System.Int32) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Replace(`0,`0) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ReplaceRange(`0,System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ReplaceSeparator(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ToFullString +M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ToString +M:Microsoft.CodeAnalysis.SourceFileResolver.#ctor(System.Collections.Generic.IEnumerable{System.String},System.String) +M:Microsoft.CodeAnalysis.SourceFileResolver.#ctor(System.Collections.Immutable.ImmutableArray{System.String},System.String) +M:Microsoft.CodeAnalysis.SourceFileResolver.#ctor(System.Collections.Immutable.ImmutableArray{System.String},System.String,System.Collections.Immutable.ImmutableArray{System.Collections.Generic.KeyValuePair{System.String,System.String}}) +M:Microsoft.CodeAnalysis.SourceFileResolver.Equals(Microsoft.CodeAnalysis.SourceFileResolver) +M:Microsoft.CodeAnalysis.SourceFileResolver.Equals(System.Object) +M:Microsoft.CodeAnalysis.SourceFileResolver.FileExists(System.String) +M:Microsoft.CodeAnalysis.SourceFileResolver.get_BaseDirectory +M:Microsoft.CodeAnalysis.SourceFileResolver.get_Default +M:Microsoft.CodeAnalysis.SourceFileResolver.get_PathMap +M:Microsoft.CodeAnalysis.SourceFileResolver.get_SearchPaths +M:Microsoft.CodeAnalysis.SourceFileResolver.GetHashCode +M:Microsoft.CodeAnalysis.SourceFileResolver.NormalizePath(System.String,System.String) +M:Microsoft.CodeAnalysis.SourceFileResolver.OpenRead(System.String) +M:Microsoft.CodeAnalysis.SourceFileResolver.ResolveReference(System.String,System.String) +M:Microsoft.CodeAnalysis.SourceProductionContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.SourceProductionContext.AddSource(System.String,System.String) +M:Microsoft.CodeAnalysis.SourceProductionContext.get_CancellationToken +M:Microsoft.CodeAnalysis.SourceProductionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) +M:Microsoft.CodeAnalysis.SourceReferenceResolver.#ctor +M:Microsoft.CodeAnalysis.SourceReferenceResolver.Equals(System.Object) +M:Microsoft.CodeAnalysis.SourceReferenceResolver.GetHashCode +M:Microsoft.CodeAnalysis.SourceReferenceResolver.NormalizePath(System.String,System.String) +M:Microsoft.CodeAnalysis.SourceReferenceResolver.OpenRead(System.String) +M:Microsoft.CodeAnalysis.SourceReferenceResolver.ReadText(System.String) +M:Microsoft.CodeAnalysis.SourceReferenceResolver.ResolveReference(System.String,System.String) +M:Microsoft.CodeAnalysis.StrongNameProvider.#ctor +M:Microsoft.CodeAnalysis.StrongNameProvider.Equals(System.Object) +M:Microsoft.CodeAnalysis.StrongNameProvider.GetHashCode +M:Microsoft.CodeAnalysis.SubsystemVersion.Create(System.Int32,System.Int32) +M:Microsoft.CodeAnalysis.SubsystemVersion.Equals(Microsoft.CodeAnalysis.SubsystemVersion) +M:Microsoft.CodeAnalysis.SubsystemVersion.Equals(System.Object) +M:Microsoft.CodeAnalysis.SubsystemVersion.get_IsValid +M:Microsoft.CodeAnalysis.SubsystemVersion.get_Major +M:Microsoft.CodeAnalysis.SubsystemVersion.get_Minor +M:Microsoft.CodeAnalysis.SubsystemVersion.get_None +M:Microsoft.CodeAnalysis.SubsystemVersion.get_Windows2000 +M:Microsoft.CodeAnalysis.SubsystemVersion.get_Windows7 +M:Microsoft.CodeAnalysis.SubsystemVersion.get_Windows8 +M:Microsoft.CodeAnalysis.SubsystemVersion.get_WindowsVista +M:Microsoft.CodeAnalysis.SubsystemVersion.get_WindowsXP +M:Microsoft.CodeAnalysis.SubsystemVersion.GetHashCode +M:Microsoft.CodeAnalysis.SubsystemVersion.ToString +M:Microsoft.CodeAnalysis.SubsystemVersion.TryParse(System.String,Microsoft.CodeAnalysis.SubsystemVersion@) +M:Microsoft.CodeAnalysis.SuppressionDescriptor.#ctor(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString) +M:Microsoft.CodeAnalysis.SuppressionDescriptor.#ctor(System.String,System.String,System.String) +M:Microsoft.CodeAnalysis.SuppressionDescriptor.Equals(Microsoft.CodeAnalysis.SuppressionDescriptor) +M:Microsoft.CodeAnalysis.SuppressionDescriptor.Equals(System.Object) +M:Microsoft.CodeAnalysis.SuppressionDescriptor.get_Id +M:Microsoft.CodeAnalysis.SuppressionDescriptor.get_Justification +M:Microsoft.CodeAnalysis.SuppressionDescriptor.get_SuppressedDiagnosticId +M:Microsoft.CodeAnalysis.SuppressionDescriptor.GetHashCode +M:Microsoft.CodeAnalysis.SymbolDisplayExtensions.ToDisplayString(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolDisplayPart}) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.#ctor(Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle,Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle,Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions,Microsoft.CodeAnalysis.SymbolDisplayMemberOptions,Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle,Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle,Microsoft.CodeAnalysis.SymbolDisplayParameterOptions,Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle,Microsoft.CodeAnalysis.SymbolDisplayLocalOptions,Microsoft.CodeAnalysis.SymbolDisplayKindOptions,Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_CSharpErrorMessageFormat +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_CSharpShortErrorMessageFormat +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_DelegateStyle +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_ExtensionMethodStyle +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_FullyQualifiedFormat +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_GenericsOptions +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_GlobalNamespaceStyle +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_KindOptions +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_LocalOptions +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MemberOptions +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MinimallyQualifiedFormat +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MiscellaneousOptions +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_ParameterOptions +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_PropertyStyle +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_TypeQualificationStyle +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_VisualBasicErrorMessageFormat +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_VisualBasicShortErrorMessageFormat +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithGlobalNamespaceStyle(Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) +M:Microsoft.CodeAnalysis.SymbolDisplayPart.#ctor(Microsoft.CodeAnalysis.SymbolDisplayPartKind,Microsoft.CodeAnalysis.ISymbol,System.String) +M:Microsoft.CodeAnalysis.SymbolDisplayPart.get_Kind +M:Microsoft.CodeAnalysis.SymbolDisplayPart.get_Symbol +M:Microsoft.CodeAnalysis.SymbolDisplayPart.ToString +M:Microsoft.CodeAnalysis.SymbolEqualityComparer.Equals(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SymbolEqualityComparer.GetHashCode(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SymbolInfo.Equals(Microsoft.CodeAnalysis.SymbolInfo) +M:Microsoft.CodeAnalysis.SymbolInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.SymbolInfo.get_CandidateReason +M:Microsoft.CodeAnalysis.SymbolInfo.get_CandidateSymbols +M:Microsoft.CodeAnalysis.SymbolInfo.get_Symbol +M:Microsoft.CodeAnalysis.SymbolInfo.GetHashCode +M:Microsoft.CodeAnalysis.SymbolVisitor.#ctor +M:Microsoft.CodeAnalysis.SymbolVisitor.DefaultVisit(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.Visit(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitField(Microsoft.CodeAnalysis.IFieldSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.#ctor +M:Microsoft.CodeAnalysis.SymbolVisitor`1.DefaultVisit(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.Visit(Microsoft.CodeAnalysis.ISymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitField(Microsoft.CodeAnalysis.IFieldSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.#ctor +M:Microsoft.CodeAnalysis.SymbolVisitor`2.DefaultVisit(Microsoft.CodeAnalysis.ISymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.get_DefaultResult +M:Microsoft.CodeAnalysis.SymbolVisitor`2.Visit(Microsoft.CodeAnalysis.ISymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitField(Microsoft.CodeAnalysis.IFieldSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol,`0) +M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol,`0) +M:Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor +M:Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor(System.String) +M:Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor(System.String,System.String) +M:Microsoft.CodeAnalysis.SyntaxAnnotation.Equals(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxAnnotation.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxAnnotation.get_Data +M:Microsoft.CodeAnalysis.SyntaxAnnotation.get_ElasticAnnotation +M:Microsoft.CodeAnalysis.SyntaxAnnotation.get_Kind +M:Microsoft.CodeAnalysis.SyntaxAnnotation.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxAnnotation.op_Equality(Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxAnnotation.op_Inequality(Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.#ctor(System.Object,System.IntPtr) +M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.BeginInvoke(System.AsyncCallback,System.Object) +M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.EndInvoke(System.IAsyncResult) +M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.Invoke +M:Microsoft.CodeAnalysis.SyntaxList.Create``1(System.ReadOnlySpan{``0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.#ctor(`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.Add(`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.Any +M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.Reset +M:Microsoft.CodeAnalysis.SyntaxList`1.Equals(Microsoft.CodeAnalysis.SyntaxList{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxList`1.First +M:Microsoft.CodeAnalysis.SyntaxList`1.FirstOrDefault +M:Microsoft.CodeAnalysis.SyntaxList`1.get_Count +M:Microsoft.CodeAnalysis.SyntaxList`1.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxList`1.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxList`1.get_Span +M:Microsoft.CodeAnalysis.SyntaxList`1.GetEnumerator +M:Microsoft.CodeAnalysis.SyntaxList`1.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxList`1.IndexOf(`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.IndexOf(System.Func{`0,System.Boolean}) +M:Microsoft.CodeAnalysis.SyntaxList`1.Insert(System.Int32,`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.Last +M:Microsoft.CodeAnalysis.SyntaxList`1.LastIndexOf(`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.LastIndexOf(System.Func{`0,System.Boolean}) +M:Microsoft.CodeAnalysis.SyntaxList`1.LastOrDefault +M:Microsoft.CodeAnalysis.SyntaxList`1.op_Equality(Microsoft.CodeAnalysis.SyntaxList{`0},Microsoft.CodeAnalysis.SyntaxList{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.op_Explicit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode})~Microsoft.CodeAnalysis.SyntaxList{`0} +M:Microsoft.CodeAnalysis.SyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SyntaxList{`0})~Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode} +M:Microsoft.CodeAnalysis.SyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxList`1.op_Inequality(Microsoft.CodeAnalysis.SyntaxList{`0},Microsoft.CodeAnalysis.SyntaxList{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.Remove(`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.RemoveAt(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxList`1.Replace(`0,`0) +M:Microsoft.CodeAnalysis.SyntaxList`1.ReplaceRange(`0,System.Collections.Generic.IEnumerable{`0}) +M:Microsoft.CodeAnalysis.SyntaxList`1.ToFullString +M:Microsoft.CodeAnalysis.SyntaxList`1.ToString +M:Microsoft.CodeAnalysis.SyntaxNode.Ancestors(System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.AncestorsAndSelf(System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.ChildNodes +M:Microsoft.CodeAnalysis.SyntaxNode.ChildNodesAndTokens +M:Microsoft.CodeAnalysis.SyntaxNode.ChildThatContainsPosition(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxNode.ChildTokens +M:Microsoft.CodeAnalysis.SyntaxNode.Contains(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxNode.ContainsDirective(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxNode.CopyAnnotationsTo``1(``0) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodes(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodes(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndSelf(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndSelf(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokens(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokens(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokensAndSelf(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokensAndSelf(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTokens(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTokens(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTrivia(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTrivia(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.EquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxNode.FindNode(Microsoft.CodeAnalysis.Text.TextSpan,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.FindToken(System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.FindTokenCore(System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.FindTokenCore(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) +M:Microsoft.CodeAnalysis.SyntaxNode.FindTrivia(System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.FindTrivia(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) +M:Microsoft.CodeAnalysis.SyntaxNode.FindTriviaCore(System.Int32,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf``1(System.Func{``0,System.Boolean},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf``2(System.Func{``0,``1,System.Boolean},``1,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsAnnotations +M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsDiagnostics +M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsDirectives +M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsSkippedText +M:Microsoft.CodeAnalysis.SyntaxNode.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxNode.get_HasLeadingTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.get_HasStructuredTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.get_HasTrailingTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.get_IsMissing +M:Microsoft.CodeAnalysis.SyntaxNode.get_IsStructuredTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.get_KindText +M:Microsoft.CodeAnalysis.SyntaxNode.get_Language +M:Microsoft.CodeAnalysis.SyntaxNode.get_Parent +M:Microsoft.CodeAnalysis.SyntaxNode.get_ParentTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.get_RawKind +M:Microsoft.CodeAnalysis.SyntaxNode.get_Span +M:Microsoft.CodeAnalysis.SyntaxNode.get_SpanStart +M:Microsoft.CodeAnalysis.SyntaxNode.get_SyntaxTree +M:Microsoft.CodeAnalysis.SyntaxNode.get_SyntaxTreeCore +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodes(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodes(System.String) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(System.String) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(System.String[]) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTokens(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTokens(System.String) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(System.String) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(System.String[]) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxNode.GetDiagnostics +M:Microsoft.CodeAnalysis.SyntaxNode.GetFirstToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.GetLastToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.GetLeadingTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.GetLocation +M:Microsoft.CodeAnalysis.SyntaxNode.GetRed``1(``0@,System.Int32) +M:Microsoft.CodeAnalysis.SyntaxNode.GetRedAtZero``1(``0@) +M:Microsoft.CodeAnalysis.SyntaxNode.GetReference +M:Microsoft.CodeAnalysis.SyntaxNode.GetText(System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +M:Microsoft.CodeAnalysis.SyntaxNode.GetTrailingTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxNode.HasAnnotations(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.SyntaxNode.HasAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxNode.InsertNodesInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.InsertTokensInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.InsertTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxNode.IsPartOfStructuredTrivia +M:Microsoft.CodeAnalysis.SyntaxNode.NormalizeWhitespaceCore(System.String,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNode.RemoveNodesCore(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) +M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceCore``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceNodeInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceTokenInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNode.SerializeTo(System.IO.Stream,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxNode.ToFullString +M:Microsoft.CodeAnalysis.SyntaxNode.ToString +M:Microsoft.CodeAnalysis.SyntaxNode.WriteTo(System.IO.TextWriter) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNode``1(Microsoft.CodeAnalysis.SyntaxNode,``0) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNodes``1(Microsoft.CodeAnalysis.SyntaxNode,``0) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNodes``1(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{``0}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertNodesAfter``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertNodesBefore``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTokensAfter``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTokensBefore``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTriviaAfter``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTriviaBefore``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.NormalizeWhitespace``1(``0,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.NormalizeWhitespace``1(``0,System.String,System.String,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.RemoveNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxRemoveOptions) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.RemoveNodes``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNodes``2(``0,System.Collections.Generic.IEnumerable{``1},System.Func{``1,``1,Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceSyntax``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceToken``1(``0,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceToken``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTokens``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.TrackNodes``1(``0,Microsoft.CodeAnalysis.SyntaxNode[]) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.TrackNodes``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutLeadingTrivia``1(``0) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrailingTrivia``1(``0) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrivia(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrivia``1(``0) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTriviaFrom``1(``0,Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.AsNode +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.AsToken +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.ChildNodesAndTokens +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.Equals(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsAnnotations +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsDiagnostics +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsDirectives +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_HasLeadingTrivia +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_HasTrailingTrivia +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsMissing +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsNode +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsToken +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Language +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Parent +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_RawKind +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Span +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_SpanStart +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_SyntaxTree +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetDiagnostics +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetFirstChildIndexSpanningPosition(Microsoft.CodeAnalysis.SyntaxNode,System.Int32) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetLeadingTrivia +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetLocation +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetNextSibling +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetPreviousSibling +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetTrailingTrivia +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotations(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Equality(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Explicit(Microsoft.CodeAnalysis.SyntaxNodeOrToken)~Microsoft.CodeAnalysis.SyntaxNode +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Explicit(Microsoft.CodeAnalysis.SyntaxNodeOrToken)~Microsoft.CodeAnalysis.SyntaxToken +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Implicit(Microsoft.CodeAnalysis.SyntaxNode)~Microsoft.CodeAnalysis.SyntaxNodeOrToken +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Implicit(Microsoft.CodeAnalysis.SyntaxToken)~Microsoft.CodeAnalysis.SyntaxNodeOrToken +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Inequality(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.ToFullString +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.ToString +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithLeadingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithTrailingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WriteTo(System.IO.TextWriter) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxNodeOrToken[]) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Add(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Any +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Equals(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.First +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.FirstOrDefault +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Count +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Span +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.GetEnumerator +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.IndexOf(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Last +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.LastOrDefault +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.op_Equality(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList,Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.op_Inequality(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList,Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Remove(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.RemoveAt(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Replace(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxNodeOrToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ToFullString +M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ToString +M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.#ctor(System.Object,System.IntPtr) +M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.BeginInvoke(System.AsyncCallback,System.Object) +M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.EndInvoke(System.IAsyncResult) +M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.Invoke +M:Microsoft.CodeAnalysis.SyntaxReference.#ctor +M:Microsoft.CodeAnalysis.SyntaxReference.get_Span +M:Microsoft.CodeAnalysis.SyntaxReference.get_SyntaxTree +M:Microsoft.CodeAnalysis.SyntaxReference.GetSyntax(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxReference.GetSyntaxAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxToken.CopyAnnotationsTo(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.Equals(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxToken.get_ContainsAnnotations +M:Microsoft.CodeAnalysis.SyntaxToken.get_ContainsDiagnostics +M:Microsoft.CodeAnalysis.SyntaxToken.get_ContainsDirectives +M:Microsoft.CodeAnalysis.SyntaxToken.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxToken.get_HasLeadingTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.get_HasStructuredTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.get_HasTrailingTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.get_IsMissing +M:Microsoft.CodeAnalysis.SyntaxToken.get_Language +M:Microsoft.CodeAnalysis.SyntaxToken.get_LeadingTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.get_Parent +M:Microsoft.CodeAnalysis.SyntaxToken.get_RawKind +M:Microsoft.CodeAnalysis.SyntaxToken.get_Span +M:Microsoft.CodeAnalysis.SyntaxToken.get_SpanStart +M:Microsoft.CodeAnalysis.SyntaxToken.get_SyntaxTree +M:Microsoft.CodeAnalysis.SyntaxToken.get_Text +M:Microsoft.CodeAnalysis.SyntaxToken.get_TrailingTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.get_Value +M:Microsoft.CodeAnalysis.SyntaxToken.get_ValueText +M:Microsoft.CodeAnalysis.SyntaxToken.GetAllTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) +M:Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.String[]) +M:Microsoft.CodeAnalysis.SyntaxToken.GetDiagnostics +M:Microsoft.CodeAnalysis.SyntaxToken.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxToken.GetLocation +M:Microsoft.CodeAnalysis.SyntaxToken.GetNextToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxToken.GetPreviousToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxToken.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxToken.HasAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxToken.HasAnnotations(System.String[]) +M:Microsoft.CodeAnalysis.SyntaxToken.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.IsPartOfStructuredTrivia +M:Microsoft.CodeAnalysis.SyntaxToken.op_Equality(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.op_Inequality(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.ToFullString +M:Microsoft.CodeAnalysis.SyntaxToken.ToString +M:Microsoft.CodeAnalysis.SyntaxToken.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.SyntaxToken.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxToken.WithTriviaFrom(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxToken.WriteTo(System.IO.TextWriter) +M:Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxToken[]) +M:Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Add(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Any +M:Microsoft.CodeAnalysis.SyntaxTokenList.Create(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SyntaxTokenList.Equals(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTokenList.First +M:Microsoft.CodeAnalysis.SyntaxTokenList.get_Count +M:Microsoft.CodeAnalysis.SyntaxTokenList.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxTokenList.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxTokenList.get_Span +M:Microsoft.CodeAnalysis.SyntaxTokenList.GetEnumerator +M:Microsoft.CodeAnalysis.SyntaxTokenList.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTokenList.IndexOf(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Last +M:Microsoft.CodeAnalysis.SyntaxTokenList.op_Equality(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.SyntaxTokenList.op_Inequality(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Remove(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.RemoveAt(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Replace(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTokenList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reverse +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.#ctor(Microsoft.CodeAnalysis.SyntaxTokenList) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Equals(Microsoft.CodeAnalysis.SyntaxTokenList.Reversed) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.GetEnumerator +M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTokenList.ToFullString +M:Microsoft.CodeAnalysis.SyntaxTokenList.ToString +M:Microsoft.CodeAnalysis.SyntaxTree.#ctor +M:Microsoft.CodeAnalysis.SyntaxTree.get_DiagnosticOptions +M:Microsoft.CodeAnalysis.SyntaxTree.get_Encoding +M:Microsoft.CodeAnalysis.SyntaxTree.get_FilePath +M:Microsoft.CodeAnalysis.SyntaxTree.get_HasCompilationUnitRoot +M:Microsoft.CodeAnalysis.SyntaxTree.get_Length +M:Microsoft.CodeAnalysis.SyntaxTree.get_Options +M:Microsoft.CodeAnalysis.SyntaxTree.get_OptionsCore +M:Microsoft.CodeAnalysis.SyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.SyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree) +M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetLineMappings(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetLineVisibility(System.Int32,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.SyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetReference(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxTree.GetRoot(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetRootAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetRootCore(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetText(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.GetTextAsync(System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTree.HasHiddenRegions +M:Microsoft.CodeAnalysis.SyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) +M:Microsoft.CodeAnalysis.SyntaxTree.ToString +M:Microsoft.CodeAnalysis.SyntaxTree.TryGetRoot(Microsoft.CodeAnalysis.SyntaxNode@) +M:Microsoft.CodeAnalysis.SyntaxTree.TryGetRootCore(Microsoft.CodeAnalysis.SyntaxNode@) +M:Microsoft.CodeAnalysis.SyntaxTree.TryGetText(Microsoft.CodeAnalysis.Text.SourceText@) +M:Microsoft.CodeAnalysis.SyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.SyntaxTree.WithDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) +M:Microsoft.CodeAnalysis.SyntaxTree.WithFilePath(System.String) +M:Microsoft.CodeAnalysis.SyntaxTree.WithRootAndOptions(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions) +M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.#ctor +M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.IsGenerated(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.TryGetDiagnosticValue(Microsoft.CodeAnalysis.SyntaxTree,System.String,System.Threading.CancellationToken,Microsoft.CodeAnalysis.ReportDiagnostic@) +M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.TryGetGlobalDiagnosticValue(System.String,System.Threading.CancellationToken,Microsoft.CodeAnalysis.ReportDiagnostic@) +M:Microsoft.CodeAnalysis.SyntaxTrivia.CopyAnnotationsTo(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTrivia.Equals(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTrivia.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_ContainsDiagnostics +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_HasStructure +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_IsDirective +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_Language +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_RawKind +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_Span +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_SpanStart +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_SyntaxTree +M:Microsoft.CodeAnalysis.SyntaxTrivia.get_Token +M:Microsoft.CodeAnalysis.SyntaxTrivia.GetAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxTrivia.GetAnnotations(System.String[]) +M:Microsoft.CodeAnalysis.SyntaxTrivia.GetDiagnostics +M:Microsoft.CodeAnalysis.SyntaxTrivia.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTrivia.GetLocation +M:Microsoft.CodeAnalysis.SyntaxTrivia.GetStructure +M:Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) +M:Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotations(System.String[]) +M:Microsoft.CodeAnalysis.SyntaxTrivia.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTrivia.IsPartOfStructuredTrivia +M:Microsoft.CodeAnalysis.SyntaxTrivia.op_Equality(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTrivia.op_Inequality(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTrivia.ToFullString +M:Microsoft.CodeAnalysis.SyntaxTrivia.ToString +M:Microsoft.CodeAnalysis.SyntaxTrivia.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.SyntaxTrivia.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) +M:Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) +M:Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(System.String) +M:Microsoft.CodeAnalysis.SyntaxTrivia.WriteTo(System.IO.TextWriter) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(Microsoft.CodeAnalysis.SyntaxTrivia[]) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Add(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Any +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Create(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.ElementAt(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Equals(Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.First +M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Count +M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Empty +M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_FullSpan +M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Span +M:Microsoft.CodeAnalysis.SyntaxTriviaList.GetEnumerator +M:Microsoft.CodeAnalysis.SyntaxTriviaList.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTriviaList.IndexOf(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Last +M:Microsoft.CodeAnalysis.SyntaxTriviaList.op_Equality(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.op_Inequality(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Remove(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.RemoveAt(System.Int32) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Replace(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reverse +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.#ctor(Microsoft.CodeAnalysis.SyntaxTriviaList) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator.get_Current +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Equals(Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Equals(System.Object) +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.GetEnumerator +M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.GetHashCode +M:Microsoft.CodeAnalysis.SyntaxTriviaList.ToFullString +M:Microsoft.CodeAnalysis.SyntaxTriviaList.ToString +M:Microsoft.CodeAnalysis.SyntaxValueProvider.CreateSyntaxProvider``1(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken,System.Boolean},System.Func{Microsoft.CodeAnalysis.GeneratorSyntaxContext,System.Threading.CancellationToken,``0}) +M:Microsoft.CodeAnalysis.SyntaxValueProvider.ForAttributeWithMetadataName``1(System.String,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken,System.Boolean},System.Func{Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext,System.Threading.CancellationToken,``0}) +M:Microsoft.CodeAnalysis.SyntaxWalker.#ctor(Microsoft.CodeAnalysis.SyntaxWalkerDepth) +M:Microsoft.CodeAnalysis.SyntaxWalker.get_Depth +M:Microsoft.CodeAnalysis.SyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode) +M:Microsoft.CodeAnalysis.SyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) +M:Microsoft.CodeAnalysis.SyntaxWalker.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) +M:Microsoft.CodeAnalysis.Text.LinePosition.#ctor(System.Int32,System.Int32) +M:Microsoft.CodeAnalysis.Text.LinePosition.CompareTo(Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.Equals(Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.LinePosition.get_Character +M:Microsoft.CodeAnalysis.Text.LinePosition.get_Line +M:Microsoft.CodeAnalysis.Text.LinePosition.get_Zero +M:Microsoft.CodeAnalysis.Text.LinePosition.GetHashCode +M:Microsoft.CodeAnalysis.Text.LinePosition.op_Equality(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.op_GreaterThan(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.op_GreaterThanOrEqual(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.op_Inequality(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.op_LessThan(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.op_LessThanOrEqual(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePosition.ToString +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.#ctor(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.Equals(Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.get_End +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.get_Start +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.GetHashCode +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.op_Equality(Microsoft.CodeAnalysis.Text.LinePositionSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.op_Inequality(Microsoft.CodeAnalysis.Text.LinePositionSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.Text.LinePositionSpan.ToString +M:Microsoft.CodeAnalysis.Text.SourceText.#ctor(System.Collections.Immutable.ImmutableArray{System.Byte},Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,Microsoft.CodeAnalysis.Text.SourceTextContainer) +M:Microsoft.CodeAnalysis.Text.SourceText.ContentEquals(Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.Text.SourceText.ContentEqualsImpl(Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.Text.SourceText.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) +M:Microsoft.CodeAnalysis.Text.SourceText.From(System.Byte[],System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean) +M:Microsoft.CodeAnalysis.Text.SourceText.From(System.Byte[],System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.Stream,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean) +M:Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.Stream,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean,System.Boolean) +M:Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.TextReader,System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +M:Microsoft.CodeAnalysis.Text.SourceText.From(System.String,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) +M:Microsoft.CodeAnalysis.Text.SourceText.get_CanBeEmbedded +M:Microsoft.CodeAnalysis.Text.SourceText.get_ChecksumAlgorithm +M:Microsoft.CodeAnalysis.Text.SourceText.get_Container +M:Microsoft.CodeAnalysis.Text.SourceText.get_Encoding +M:Microsoft.CodeAnalysis.Text.SourceText.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.Text.SourceText.get_Length +M:Microsoft.CodeAnalysis.Text.SourceText.get_Lines +M:Microsoft.CodeAnalysis.Text.SourceText.GetChangeRanges(Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.Text.SourceText.GetChecksum +M:Microsoft.CodeAnalysis.Text.SourceText.GetContentHash +M:Microsoft.CodeAnalysis.Text.SourceText.GetLinesCore +M:Microsoft.CodeAnalysis.Text.SourceText.GetSubText(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.SourceText.GetSubText(System.Int32) +M:Microsoft.CodeAnalysis.Text.SourceText.GetTextChanges(Microsoft.CodeAnalysis.Text.SourceText) +M:Microsoft.CodeAnalysis.Text.SourceText.Replace(Microsoft.CodeAnalysis.Text.TextSpan,System.String) +M:Microsoft.CodeAnalysis.Text.SourceText.Replace(System.Int32,System.Int32,System.String) +M:Microsoft.CodeAnalysis.Text.SourceText.ToString +M:Microsoft.CodeAnalysis.Text.SourceText.ToString(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.SourceText.WithChanges(Microsoft.CodeAnalysis.Text.TextChange[]) +M:Microsoft.CodeAnalysis.Text.SourceText.WithChanges(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChange}) +M:Microsoft.CodeAnalysis.Text.SourceText.Write(System.IO.TextWriter,Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Text.SourceText.Write(System.IO.TextWriter,System.Threading.CancellationToken) +M:Microsoft.CodeAnalysis.Text.SourceTextContainer.#ctor +M:Microsoft.CodeAnalysis.Text.SourceTextContainer.add_TextChanged(System.EventHandler{Microsoft.CodeAnalysis.Text.TextChangeEventArgs}) +M:Microsoft.CodeAnalysis.Text.SourceTextContainer.get_CurrentText +M:Microsoft.CodeAnalysis.Text.SourceTextContainer.remove_TextChanged(System.EventHandler{Microsoft.CodeAnalysis.Text.TextChangeEventArgs}) +M:Microsoft.CodeAnalysis.Text.TextChange.#ctor(Microsoft.CodeAnalysis.Text.TextSpan,System.String) +M:Microsoft.CodeAnalysis.Text.TextChange.Equals(Microsoft.CodeAnalysis.Text.TextChange) +M:Microsoft.CodeAnalysis.Text.TextChange.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.TextChange.get_NewText +M:Microsoft.CodeAnalysis.Text.TextChange.get_NoChanges +M:Microsoft.CodeAnalysis.Text.TextChange.get_Span +M:Microsoft.CodeAnalysis.Text.TextChange.GetHashCode +M:Microsoft.CodeAnalysis.Text.TextChange.op_Equality(Microsoft.CodeAnalysis.Text.TextChange,Microsoft.CodeAnalysis.Text.TextChange) +M:Microsoft.CodeAnalysis.Text.TextChange.op_Implicit(Microsoft.CodeAnalysis.Text.TextChange)~Microsoft.CodeAnalysis.Text.TextChangeRange +M:Microsoft.CodeAnalysis.Text.TextChange.op_Inequality(Microsoft.CodeAnalysis.Text.TextChange,Microsoft.CodeAnalysis.Text.TextChange) +M:Microsoft.CodeAnalysis.Text.TextChange.ToString +M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.#ctor(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.TextChangeRange[]) +M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.#ctor(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.SourceText,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChangeRange}) +M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_Changes +M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_NewText +M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_OldText +M:Microsoft.CodeAnalysis.Text.TextChangeRange.#ctor(Microsoft.CodeAnalysis.Text.TextSpan,System.Int32) +M:Microsoft.CodeAnalysis.Text.TextChangeRange.Collapse(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChangeRange}) +M:Microsoft.CodeAnalysis.Text.TextChangeRange.Equals(Microsoft.CodeAnalysis.Text.TextChangeRange) +M:Microsoft.CodeAnalysis.Text.TextChangeRange.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.TextChangeRange.get_NewLength +M:Microsoft.CodeAnalysis.Text.TextChangeRange.get_NoChanges +M:Microsoft.CodeAnalysis.Text.TextChangeRange.get_Span +M:Microsoft.CodeAnalysis.Text.TextChangeRange.GetHashCode +M:Microsoft.CodeAnalysis.Text.TextChangeRange.op_Equality(Microsoft.CodeAnalysis.Text.TextChangeRange,Microsoft.CodeAnalysis.Text.TextChangeRange) +M:Microsoft.CodeAnalysis.Text.TextChangeRange.op_Inequality(Microsoft.CodeAnalysis.Text.TextChangeRange,Microsoft.CodeAnalysis.Text.TextChangeRange) +M:Microsoft.CodeAnalysis.Text.TextChangeRange.ToString +M:Microsoft.CodeAnalysis.Text.TextLine.Equals(Microsoft.CodeAnalysis.Text.TextLine) +M:Microsoft.CodeAnalysis.Text.TextLine.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.TextLine.FromSpan(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextLine.get_End +M:Microsoft.CodeAnalysis.Text.TextLine.get_EndIncludingLineBreak +M:Microsoft.CodeAnalysis.Text.TextLine.get_LineNumber +M:Microsoft.CodeAnalysis.Text.TextLine.get_Span +M:Microsoft.CodeAnalysis.Text.TextLine.get_SpanIncludingLineBreak +M:Microsoft.CodeAnalysis.Text.TextLine.get_Start +M:Microsoft.CodeAnalysis.Text.TextLine.get_Text +M:Microsoft.CodeAnalysis.Text.TextLine.GetHashCode +M:Microsoft.CodeAnalysis.Text.TextLine.op_Equality(Microsoft.CodeAnalysis.Text.TextLine,Microsoft.CodeAnalysis.Text.TextLine) +M:Microsoft.CodeAnalysis.Text.TextLine.op_Inequality(Microsoft.CodeAnalysis.Text.TextLine,Microsoft.CodeAnalysis.Text.TextLine) +M:Microsoft.CodeAnalysis.Text.TextLine.ToString +M:Microsoft.CodeAnalysis.Text.TextLineCollection.#ctor +M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.get_Current +M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.GetHashCode +M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.MoveNext +M:Microsoft.CodeAnalysis.Text.TextLineCollection.get_Count +M:Microsoft.CodeAnalysis.Text.TextLineCollection.get_Item(System.Int32) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetEnumerator +M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetLineFromPosition(System.Int32) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetLinePosition(System.Int32) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetLinePositionSpan(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetPosition(Microsoft.CodeAnalysis.Text.LinePosition) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetTextSpan(Microsoft.CodeAnalysis.Text.LinePositionSpan) +M:Microsoft.CodeAnalysis.Text.TextLineCollection.IndexOf(System.Int32) +M:Microsoft.CodeAnalysis.Text.TextSpan.#ctor(System.Int32,System.Int32) +M:Microsoft.CodeAnalysis.Text.TextSpan.CompareTo(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.Contains(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.Contains(System.Int32) +M:Microsoft.CodeAnalysis.Text.TextSpan.Equals(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.Equals(System.Object) +M:Microsoft.CodeAnalysis.Text.TextSpan.FromBounds(System.Int32,System.Int32) +M:Microsoft.CodeAnalysis.Text.TextSpan.get_End +M:Microsoft.CodeAnalysis.Text.TextSpan.get_IsEmpty +M:Microsoft.CodeAnalysis.Text.TextSpan.get_Length +M:Microsoft.CodeAnalysis.Text.TextSpan.get_Start +M:Microsoft.CodeAnalysis.Text.TextSpan.GetHashCode +M:Microsoft.CodeAnalysis.Text.TextSpan.Intersection(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.IntersectsWith(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.IntersectsWith(System.Int32) +M:Microsoft.CodeAnalysis.Text.TextSpan.op_Equality(Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.op_Inequality(Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.Overlap(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.OverlapsWith(Microsoft.CodeAnalysis.Text.TextSpan) +M:Microsoft.CodeAnalysis.Text.TextSpan.ToString +M:Microsoft.CodeAnalysis.TypedConstant.Equals(Microsoft.CodeAnalysis.TypedConstant) +M:Microsoft.CodeAnalysis.TypedConstant.Equals(System.Object) +M:Microsoft.CodeAnalysis.TypedConstant.get_IsNull +M:Microsoft.CodeAnalysis.TypedConstant.get_Kind +M:Microsoft.CodeAnalysis.TypedConstant.get_Type +M:Microsoft.CodeAnalysis.TypedConstant.get_Value +M:Microsoft.CodeAnalysis.TypedConstant.get_Values +M:Microsoft.CodeAnalysis.TypedConstant.GetHashCode +M:Microsoft.CodeAnalysis.TypeInfo.Equals(Microsoft.CodeAnalysis.TypeInfo) +M:Microsoft.CodeAnalysis.TypeInfo.Equals(System.Object) +M:Microsoft.CodeAnalysis.TypeInfo.get_ConvertedNullability +M:Microsoft.CodeAnalysis.TypeInfo.get_ConvertedType +M:Microsoft.CodeAnalysis.TypeInfo.get_Nullability +M:Microsoft.CodeAnalysis.TypeInfo.get_Type +M:Microsoft.CodeAnalysis.TypeInfo.GetHashCode +M:Microsoft.CodeAnalysis.UnresolvedMetadataReference.get_Display +M:Microsoft.CodeAnalysis.UnresolvedMetadataReference.get_Reference +M:Microsoft.CodeAnalysis.XmlFileResolver.#ctor(System.String) +M:Microsoft.CodeAnalysis.XmlFileResolver.Equals(System.Object) +M:Microsoft.CodeAnalysis.XmlFileResolver.FileExists(System.String) +M:Microsoft.CodeAnalysis.XmlFileResolver.get_BaseDirectory +M:Microsoft.CodeAnalysis.XmlFileResolver.get_Default +M:Microsoft.CodeAnalysis.XmlFileResolver.GetHashCode +M:Microsoft.CodeAnalysis.XmlFileResolver.OpenRead(System.String) +M:Microsoft.CodeAnalysis.XmlFileResolver.ResolveReference(System.String,System.String) +M:Microsoft.CodeAnalysis.XmlReferenceResolver.#ctor +M:Microsoft.CodeAnalysis.XmlReferenceResolver.Equals(System.Object) +M:Microsoft.CodeAnalysis.XmlReferenceResolver.GetHashCode +M:Microsoft.CodeAnalysis.XmlReferenceResolver.OpenRead(System.String) +M:Microsoft.CodeAnalysis.XmlReferenceResolver.ResolveReference(System.String,System.String) +T:Microsoft.CodeAnalysis.Accessibility +T:Microsoft.CodeAnalysis.AdditionalText +T:Microsoft.CodeAnalysis.AnalyzerConfig +T:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult +T:Microsoft.CodeAnalysis.AnalyzerConfigSet +T:Microsoft.CodeAnalysis.AnnotationExtensions +T:Microsoft.CodeAnalysis.AssemblyIdentity +T:Microsoft.CodeAnalysis.AssemblyIdentityComparer +T:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult +T:Microsoft.CodeAnalysis.AssemblyIdentityParts +T:Microsoft.CodeAnalysis.AssemblyMetadata +T:Microsoft.CodeAnalysis.AttributeData +T:Microsoft.CodeAnalysis.CandidateReason +T:Microsoft.CodeAnalysis.CaseInsensitiveComparison +T:Microsoft.CodeAnalysis.ChildSyntaxList +T:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator +T:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed +T:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator +T:Microsoft.CodeAnalysis.CommandLineAnalyzerReference +T:Microsoft.CodeAnalysis.CommandLineArguments +T:Microsoft.CodeAnalysis.CommandLineReference +T:Microsoft.CodeAnalysis.CommandLineSourceFile +T:Microsoft.CodeAnalysis.Compilation +T:Microsoft.CodeAnalysis.CompilationOptions +T:Microsoft.CodeAnalysis.CompilationReference +T:Microsoft.CodeAnalysis.ControlFlowAnalysis +T:Microsoft.CodeAnalysis.CustomModifier +T:Microsoft.CodeAnalysis.DataFlowAnalysis +T:Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer +T:Microsoft.CodeAnalysis.Diagnostic +T:Microsoft.CodeAnalysis.DiagnosticDescriptor +T:Microsoft.CodeAnalysis.DiagnosticFormatter +T:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider`1 +T:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions +T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference +T:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1 +T:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers +T:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions +T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer +T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute +T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions +T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor +T:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags +T:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider`1 +T:Microsoft.CodeAnalysis.Diagnostics.Suppression +T:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo +T:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext +T:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider`1 +T:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo +T:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference +T:Microsoft.CodeAnalysis.DiagnosticSeverity +T:Microsoft.CodeAnalysis.DllImportData +T:Microsoft.CodeAnalysis.DocumentationCommentId +T:Microsoft.CodeAnalysis.DocumentationMode +T:Microsoft.CodeAnalysis.DocumentationProvider +T:Microsoft.CodeAnalysis.EmbeddedText +T:Microsoft.CodeAnalysis.Emit.DebugInformationFormat +T:Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation +T:Microsoft.CodeAnalysis.Emit.EmitBaseline +T:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult +T:Microsoft.CodeAnalysis.Emit.EmitOptions +T:Microsoft.CodeAnalysis.Emit.EmitResult +T:Microsoft.CodeAnalysis.Emit.InstrumentationKind +T:Microsoft.CodeAnalysis.Emit.MethodInstrumentation +T:Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit +T:Microsoft.CodeAnalysis.Emit.SemanticEdit +T:Microsoft.CodeAnalysis.Emit.SemanticEditKind +T:Microsoft.CodeAnalysis.ErrorLogOptions +T:Microsoft.CodeAnalysis.FileLinePositionSpan +T:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock +T:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind +T:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion +T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind +T:Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation +T:Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation +T:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation +T:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation +T:Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation +T:Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation +T:Microsoft.CodeAnalysis.GeneratedKind +T:Microsoft.CodeAnalysis.GeneratedSourceResult +T:Microsoft.CodeAnalysis.GeneratorAttribute +T:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext +T:Microsoft.CodeAnalysis.GeneratorDriver +T:Microsoft.CodeAnalysis.GeneratorDriverOptions +T:Microsoft.CodeAnalysis.GeneratorDriverRunResult +T:Microsoft.CodeAnalysis.GeneratorDriverTimingInfo +T:Microsoft.CodeAnalysis.GeneratorExecutionContext +T:Microsoft.CodeAnalysis.GeneratorExtensions +T:Microsoft.CodeAnalysis.GeneratorInitializationContext +T:Microsoft.CodeAnalysis.GeneratorPostInitializationContext +T:Microsoft.CodeAnalysis.GeneratorRunResult +T:Microsoft.CodeAnalysis.GeneratorSyntaxContext +T:Microsoft.CodeAnalysis.GeneratorTimingInfo +T:Microsoft.CodeAnalysis.IAliasSymbol +T:Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader +T:Microsoft.CodeAnalysis.IArrayTypeSymbol +T:Microsoft.CodeAnalysis.IAssemblySymbol +T:Microsoft.CodeAnalysis.ICompilationUnitSyntax +T:Microsoft.CodeAnalysis.IDiscardSymbol +T:Microsoft.CodeAnalysis.IDynamicTypeSymbol +T:Microsoft.CodeAnalysis.IErrorTypeSymbol +T:Microsoft.CodeAnalysis.IEventSymbol +T:Microsoft.CodeAnalysis.IFieldSymbol +T:Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol +T:Microsoft.CodeAnalysis.IImportScope +T:Microsoft.CodeAnalysis.IIncrementalGenerator +T:Microsoft.CodeAnalysis.ILabelSymbol +T:Microsoft.CodeAnalysis.ILocalSymbol +T:Microsoft.CodeAnalysis.IMethodSymbol +T:Microsoft.CodeAnalysis.IModuleSymbol +T:Microsoft.CodeAnalysis.ImportedNamespaceOrType +T:Microsoft.CodeAnalysis.ImportedXmlNamespace +T:Microsoft.CodeAnalysis.INamedTypeSymbol +T:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol +T:Microsoft.CodeAnalysis.INamespaceSymbol +T:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext +T:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind +T:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext +T:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep +T:Microsoft.CodeAnalysis.IncrementalStepRunReason +T:Microsoft.CodeAnalysis.IncrementalValueProvider`1 +T:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions +T:Microsoft.CodeAnalysis.IncrementalValuesProvider`1 +T:Microsoft.CodeAnalysis.IOperation +T:Microsoft.CodeAnalysis.IOperation.OperationList +T:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator +T:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed +T:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator +T:Microsoft.CodeAnalysis.IParameterSymbol +T:Microsoft.CodeAnalysis.IPointerTypeSymbol +T:Microsoft.CodeAnalysis.IPreprocessingSymbol +T:Microsoft.CodeAnalysis.IPropertySymbol +T:Microsoft.CodeAnalysis.IRangeVariableSymbol +T:Microsoft.CodeAnalysis.ISkippedTokensTriviaSyntax +T:Microsoft.CodeAnalysis.ISourceAssemblySymbol +T:Microsoft.CodeAnalysis.ISourceGenerator +T:Microsoft.CodeAnalysis.IStructuredTriviaSyntax +T:Microsoft.CodeAnalysis.ISymbol +T:Microsoft.CodeAnalysis.ISymbolExtensions +T:Microsoft.CodeAnalysis.ISyntaxContextReceiver +T:Microsoft.CodeAnalysis.ISyntaxReceiver +T:Microsoft.CodeAnalysis.ITypeParameterSymbol +T:Microsoft.CodeAnalysis.ITypeSymbol +T:Microsoft.CodeAnalysis.LanguageNames +T:Microsoft.CodeAnalysis.LineMapping +T:Microsoft.CodeAnalysis.LineVisibility +T:Microsoft.CodeAnalysis.LocalizableResourceString +T:Microsoft.CodeAnalysis.LocalizableString +T:Microsoft.CodeAnalysis.Location +T:Microsoft.CodeAnalysis.LocationKind +T:Microsoft.CodeAnalysis.Metadata +T:Microsoft.CodeAnalysis.MetadataId +T:Microsoft.CodeAnalysis.MetadataImageKind +T:Microsoft.CodeAnalysis.MetadataImportOptions +T:Microsoft.CodeAnalysis.MetadataReference +T:Microsoft.CodeAnalysis.MetadataReferenceProperties +T:Microsoft.CodeAnalysis.MetadataReferenceResolver +T:Microsoft.CodeAnalysis.MethodKind +T:Microsoft.CodeAnalysis.ModelExtensions +T:Microsoft.CodeAnalysis.ModuleMetadata +T:Microsoft.CodeAnalysis.NamespaceKind +T:Microsoft.CodeAnalysis.NullabilityInfo +T:Microsoft.CodeAnalysis.NullableAnnotation +T:Microsoft.CodeAnalysis.NullableContext +T:Microsoft.CodeAnalysis.NullableContextExtensions +T:Microsoft.CodeAnalysis.NullableContextOptions +T:Microsoft.CodeAnalysis.NullableContextOptionsExtensions +T:Microsoft.CodeAnalysis.NullableFlowState +T:Microsoft.CodeAnalysis.OperationKind +T:Microsoft.CodeAnalysis.Operations.ArgumentKind +T:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind +T:Microsoft.CodeAnalysis.Operations.BranchKind +T:Microsoft.CodeAnalysis.Operations.CaseKind +T:Microsoft.CodeAnalysis.Operations.CommonConversion +T:Microsoft.CodeAnalysis.Operations.IAddressOfOperation +T:Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation +T:Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation +T:Microsoft.CodeAnalysis.Operations.IArgumentOperation +T:Microsoft.CodeAnalysis.Operations.IArrayCreationOperation +T:Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IAssignmentOperation +T:Microsoft.CodeAnalysis.Operations.IAttributeOperation +T:Microsoft.CodeAnalysis.Operations.IAwaitOperation +T:Microsoft.CodeAnalysis.Operations.IBinaryOperation +T:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation +T:Microsoft.CodeAnalysis.Operations.IBlockOperation +T:Microsoft.CodeAnalysis.Operations.IBranchOperation +T:Microsoft.CodeAnalysis.Operations.ICaseClauseOperation +T:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation +T:Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation +T:Microsoft.CodeAnalysis.Operations.ICoalesceOperation +T:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation +T:Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation +T:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation +T:Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation +T:Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation +T:Microsoft.CodeAnalysis.Operations.IConditionalOperation +T:Microsoft.CodeAnalysis.Operations.IConstantPatternOperation +T:Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation +T:Microsoft.CodeAnalysis.Operations.IConversionOperation +T:Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation +T:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation +T:Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation +T:Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation +T:Microsoft.CodeAnalysis.Operations.IDefaultValueOperation +T:Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation +T:Microsoft.CodeAnalysis.Operations.IDiscardOperation +T:Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation +T:Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation +T:Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation +T:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation +T:Microsoft.CodeAnalysis.Operations.IEmptyOperation +T:Microsoft.CodeAnalysis.Operations.IEndOperation +T:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation +T:Microsoft.CodeAnalysis.Operations.IEventReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation +T:Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation +T:Microsoft.CodeAnalysis.Operations.IForLoopOperation +T:Microsoft.CodeAnalysis.Operations.IForToLoopOperation +T:Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation +T:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation +T:Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation +T:Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringContentOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation +T:Microsoft.CodeAnalysis.Operations.IInterpolationOperation +T:Microsoft.CodeAnalysis.Operations.IInvalidOperation +T:Microsoft.CodeAnalysis.Operations.IInvocationOperation +T:Microsoft.CodeAnalysis.Operations.IIsPatternOperation +T:Microsoft.CodeAnalysis.Operations.IIsTypeOperation +T:Microsoft.CodeAnalysis.Operations.ILabeledOperation +T:Microsoft.CodeAnalysis.Operations.IListPatternOperation +T:Microsoft.CodeAnalysis.Operations.ILiteralOperation +T:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation +T:Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation +T:Microsoft.CodeAnalysis.Operations.ILockOperation +T:Microsoft.CodeAnalysis.Operations.ILoopOperation +T:Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation +T:Microsoft.CodeAnalysis.Operations.IMethodBodyOperation +T:Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation +T:Microsoft.CodeAnalysis.Operations.INameOfOperation +T:Microsoft.CodeAnalysis.Operations.INegatedPatternOperation +T:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind +T:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind +T:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation +T:Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation +T:Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IParenthesizedOperation +T:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation +T:Microsoft.CodeAnalysis.Operations.IPatternOperation +T:Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation +T:Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation +T:Microsoft.CodeAnalysis.Operations.IRaiseEventOperation +T:Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation +T:Microsoft.CodeAnalysis.Operations.IRangeOperation +T:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation +T:Microsoft.CodeAnalysis.Operations.IReDimClauseOperation +T:Microsoft.CodeAnalysis.Operations.IReDimOperation +T:Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation +T:Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation +T:Microsoft.CodeAnalysis.Operations.IReturnOperation +T:Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation +T:Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation +T:Microsoft.CodeAnalysis.Operations.ISizeOfOperation +T:Microsoft.CodeAnalysis.Operations.ISlicePatternOperation +T:Microsoft.CodeAnalysis.Operations.ISpreadOperation +T:Microsoft.CodeAnalysis.Operations.IStopOperation +T:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation +T:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation +T:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation +T:Microsoft.CodeAnalysis.Operations.ISwitchOperation +T:Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IThrowOperation +T:Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation +T:Microsoft.CodeAnalysis.Operations.ITryOperation +T:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation +T:Microsoft.CodeAnalysis.Operations.ITupleOperation +T:Microsoft.CodeAnalysis.Operations.ITypeOfOperation +T:Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation +T:Microsoft.CodeAnalysis.Operations.ITypePatternOperation +T:Microsoft.CodeAnalysis.Operations.IUnaryOperation +T:Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation +T:Microsoft.CodeAnalysis.Operations.IUsingOperation +T:Microsoft.CodeAnalysis.Operations.IUtf8StringOperation +T:Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation +T:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation +T:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation +T:Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation +T:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation +T:Microsoft.CodeAnalysis.Operations.IWithOperation +T:Microsoft.CodeAnalysis.Operations.LoopKind +T:Microsoft.CodeAnalysis.Operations.OperationExtensions +T:Microsoft.CodeAnalysis.Operations.OperationVisitor +T:Microsoft.CodeAnalysis.Operations.OperationVisitor`2 +T:Microsoft.CodeAnalysis.Operations.OperationWalker +T:Microsoft.CodeAnalysis.Operations.OperationWalker`1 +T:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind +T:Microsoft.CodeAnalysis.OptimizationLevel +T:Microsoft.CodeAnalysis.Optional`1 +T:Microsoft.CodeAnalysis.OutputKind +T:Microsoft.CodeAnalysis.ParseOptions +T:Microsoft.CodeAnalysis.Platform +T:Microsoft.CodeAnalysis.PortableExecutableReference +T:Microsoft.CodeAnalysis.PreprocessingSymbolInfo +T:Microsoft.CodeAnalysis.RefKind +T:Microsoft.CodeAnalysis.ReportDiagnostic +T:Microsoft.CodeAnalysis.ResourceDescription +T:Microsoft.CodeAnalysis.RuleSet +T:Microsoft.CodeAnalysis.RuleSetInclude +T:Microsoft.CodeAnalysis.RuntimeCapability +T:Microsoft.CodeAnalysis.SarifVersion +T:Microsoft.CodeAnalysis.SarifVersionFacts +T:Microsoft.CodeAnalysis.ScopedKind +T:Microsoft.CodeAnalysis.ScriptCompilationInfo +T:Microsoft.CodeAnalysis.SemanticModel +T:Microsoft.CodeAnalysis.SemanticModelOptions +T:Microsoft.CodeAnalysis.SeparatedSyntaxList +T:Microsoft.CodeAnalysis.SeparatedSyntaxList`1 +T:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator +T:Microsoft.CodeAnalysis.SourceCodeKind +T:Microsoft.CodeAnalysis.SourceFileResolver +T:Microsoft.CodeAnalysis.SourceProductionContext +T:Microsoft.CodeAnalysis.SourceReferenceResolver +T:Microsoft.CodeAnalysis.SpecialType +T:Microsoft.CodeAnalysis.SpeculativeBindingOption +T:Microsoft.CodeAnalysis.StrongNameProvider +T:Microsoft.CodeAnalysis.SubsystemVersion +T:Microsoft.CodeAnalysis.SuppressionDescriptor +T:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle +T:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle +T:Microsoft.CodeAnalysis.SymbolDisplayExtensions +T:Microsoft.CodeAnalysis.SymbolDisplayFormat +T:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions +T:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle +T:Microsoft.CodeAnalysis.SymbolDisplayKindOptions +T:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions +T:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions +T:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions +T:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions +T:Microsoft.CodeAnalysis.SymbolDisplayPart +T:Microsoft.CodeAnalysis.SymbolDisplayPartKind +T:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle +T:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle +T:Microsoft.CodeAnalysis.SymbolEqualityComparer +T:Microsoft.CodeAnalysis.SymbolFilter +T:Microsoft.CodeAnalysis.SymbolInfo +T:Microsoft.CodeAnalysis.SymbolKind +T:Microsoft.CodeAnalysis.SymbolVisitor +T:Microsoft.CodeAnalysis.SymbolVisitor`1 +T:Microsoft.CodeAnalysis.SymbolVisitor`2 +T:Microsoft.CodeAnalysis.SyntaxAnnotation +T:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator +T:Microsoft.CodeAnalysis.SyntaxList +T:Microsoft.CodeAnalysis.SyntaxList`1 +T:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator +T:Microsoft.CodeAnalysis.SyntaxNode +T:Microsoft.CodeAnalysis.SyntaxNodeExtensions +T:Microsoft.CodeAnalysis.SyntaxNodeOrToken +T:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList +T:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator +T:Microsoft.CodeAnalysis.SyntaxReceiverCreator +T:Microsoft.CodeAnalysis.SyntaxReference +T:Microsoft.CodeAnalysis.SyntaxRemoveOptions +T:Microsoft.CodeAnalysis.SyntaxToken +T:Microsoft.CodeAnalysis.SyntaxTokenList +T:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator +T:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed +T:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator +T:Microsoft.CodeAnalysis.SyntaxTree +T:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider +T:Microsoft.CodeAnalysis.SyntaxTrivia +T:Microsoft.CodeAnalysis.SyntaxTriviaList +T:Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator +T:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed +T:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator +T:Microsoft.CodeAnalysis.SyntaxValueProvider +T:Microsoft.CodeAnalysis.SyntaxWalker +T:Microsoft.CodeAnalysis.SyntaxWalkerDepth +T:Microsoft.CodeAnalysis.Text.LinePosition +T:Microsoft.CodeAnalysis.Text.LinePositionSpan +T:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm +T:Microsoft.CodeAnalysis.Text.SourceText +T:Microsoft.CodeAnalysis.Text.SourceTextContainer +T:Microsoft.CodeAnalysis.Text.TextChange +T:Microsoft.CodeAnalysis.Text.TextChangeEventArgs +T:Microsoft.CodeAnalysis.Text.TextChangeRange +T:Microsoft.CodeAnalysis.Text.TextLine +T:Microsoft.CodeAnalysis.Text.TextLineCollection +T:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator +T:Microsoft.CodeAnalysis.Text.TextSpan +T:Microsoft.CodeAnalysis.TypedConstant +T:Microsoft.CodeAnalysis.TypedConstantKind +T:Microsoft.CodeAnalysis.TypeInfo +T:Microsoft.CodeAnalysis.TypeKind +T:Microsoft.CodeAnalysis.TypeParameterKind +T:Microsoft.CodeAnalysis.UnresolvedMetadataReference +T:Microsoft.CodeAnalysis.VarianceKind +T:Microsoft.CodeAnalysis.WellKnownDiagnosticTags +T:Microsoft.CodeAnalysis.WellKnownGeneratorInputs +T:Microsoft.CodeAnalysis.WellKnownGeneratorOutputs +T:Microsoft.CodeAnalysis.WellKnownMemberNames +T:Microsoft.CodeAnalysis.XmlFileResolver +T:Microsoft.CodeAnalysis.XmlReferenceResolver \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt new file mode 100644 index 0000000000000..cca2b21a94568 --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt @@ -0,0 +1,783 @@ +F:System.Collections.Immutable.ImmutableArray`1.Empty +F:System.Collections.Immutable.ImmutableDictionary`2.Empty +F:System.Collections.Immutable.ImmutableHashSet`1.Empty +F:System.Collections.Immutable.ImmutableList`1.Empty +F:System.Collections.Immutable.ImmutableSortedDictionary`2.Empty +F:System.Collections.Immutable.ImmutableSortedSet`1.Empty +M:System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Frozen.FrozenDictionary`2.ContainsKey(`0) +M:System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) +M:System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Span{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Frozen.FrozenDictionary`2.Enumerator.get_Current +M:System.Collections.Frozen.FrozenDictionary`2.Enumerator.MoveNext +M:System.Collections.Frozen.FrozenDictionary`2.get_Comparer +M:System.Collections.Frozen.FrozenDictionary`2.get_Count +M:System.Collections.Frozen.FrozenDictionary`2.get_Empty +M:System.Collections.Frozen.FrozenDictionary`2.get_Item(`0) +M:System.Collections.Frozen.FrozenDictionary`2.get_Keys +M:System.Collections.Frozen.FrozenDictionary`2.get_Values +M:System.Collections.Frozen.FrozenDictionary`2.GetEnumerator +M:System.Collections.Frozen.FrozenDictionary`2.GetValueRefOrNullRef(`0) +M:System.Collections.Frozen.FrozenDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Frozen.FrozenSet.ToFrozenSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Frozen.FrozenSet`1.Contains(`0) +M:System.Collections.Frozen.FrozenSet`1.CopyTo(`0[],System.Int32) +M:System.Collections.Frozen.FrozenSet`1.CopyTo(System.Span{`0}) +M:System.Collections.Frozen.FrozenSet`1.Enumerator.get_Current +M:System.Collections.Frozen.FrozenSet`1.Enumerator.MoveNext +M:System.Collections.Frozen.FrozenSet`1.get_Comparer +M:System.Collections.Frozen.FrozenSet`1.get_Count +M:System.Collections.Frozen.FrozenSet`1.get_Empty +M:System.Collections.Frozen.FrozenSet`1.get_Items +M:System.Collections.Frozen.FrozenSet`1.GetEnumerator +M:System.Collections.Frozen.FrozenSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Frozen.FrozenSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Frozen.FrozenSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Frozen.FrozenSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Frozen.FrozenSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Frozen.FrozenSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Frozen.FrozenSet`1.TryGetValue(`0,`0@) +M:System.Collections.Immutable.IImmutableDictionary`2.Add(`0,`1) +M:System.Collections.Immutable.IImmutableDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.IImmutableDictionary`2.Clear +M:System.Collections.Immutable.IImmutableDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.IImmutableDictionary`2.Remove(`0) +M:System.Collections.Immutable.IImmutableDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableDictionary`2.SetItem(`0,`1) +M:System.Collections.Immutable.IImmutableDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.IImmutableDictionary`2.TryGetKey(`0,`0@) +M:System.Collections.Immutable.IImmutableList`1.Add(`0) +M:System.Collections.Immutable.IImmutableList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableList`1.Clear +M:System.Collections.Immutable.IImmutableList`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.IImmutableList`1.Insert(System.Int32,`0) +M:System.Collections.Immutable.IImmutableList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableList`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.IImmutableList`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.IImmutableList`1.RemoveAll(System.Predicate{`0}) +M:System.Collections.Immutable.IImmutableList`1.RemoveAt(System.Int32) +M:System.Collections.Immutable.IImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.IImmutableList`1.RemoveRange(System.Int32,System.Int32) +M:System.Collections.Immutable.IImmutableList`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.IImmutableList`1.SetItem(System.Int32,`0) +M:System.Collections.Immutable.IImmutableQueue`1.Clear +M:System.Collections.Immutable.IImmutableQueue`1.Dequeue +M:System.Collections.Immutable.IImmutableQueue`1.Enqueue(`0) +M:System.Collections.Immutable.IImmutableQueue`1.get_IsEmpty +M:System.Collections.Immutable.IImmutableQueue`1.Peek +M:System.Collections.Immutable.IImmutableSet`1.Add(`0) +M:System.Collections.Immutable.IImmutableSet`1.Clear +M:System.Collections.Immutable.IImmutableSet`1.Contains(`0) +M:System.Collections.Immutable.IImmutableSet`1.Except(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.Remove(`0) +M:System.Collections.Immutable.IImmutableSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableSet`1.TryGetValue(`0,`0@) +M:System.Collections.Immutable.IImmutableSet`1.Union(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.IImmutableStack`1.Clear +M:System.Collections.Immutable.IImmutableStack`1.get_IsEmpty +M:System.Collections.Immutable.IImmutableStack`1.Peek +M:System.Collections.Immutable.IImmutableStack`1.Pop +M:System.Collections.Immutable.IImmutableStack`1.Push(`0) +M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},``0) +M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},``0,System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,``0) +M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,``0,System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableArray.Create``1 +M:System.Collections.Immutable.ImmutableArray.Create``1(``0) +M:System.Collections.Immutable.ImmutableArray.Create``1(``0,``0) +M:System.Collections.Immutable.ImmutableArray.Create``1(``0,``0,``0) +M:System.Collections.Immutable.ImmutableArray.Create``1(``0,``0,``0,``0) +M:System.Collections.Immutable.ImmutableArray.Create``1(``0[]) +M:System.Collections.Immutable.ImmutableArray.Create``1(``0[],System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray.Create``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray.Create``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableArray.Create``1(System.Span{``0}) +M:System.Collections.Immutable.ImmutableArray.CreateBuilder``1 +M:System.Collections.Immutable.ImmutableArray.CreateBuilder``1(System.Int32) +M:System.Collections.Immutable.ImmutableArray.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableArray.CreateRange``2(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1}) +M:System.Collections.Immutable.ImmutableArray.CreateRange``2(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,System.Func{``0,``1}) +M:System.Collections.Immutable.ImmutableArray.CreateRange``3(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1,``2},``1) +M:System.Collections.Immutable.ImmutableArray.CreateRange``3(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,System.Func{``0,``1,``2},``1) +M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Span{``0}) +M:System.Collections.Immutable.ImmutableArray`1.Add(`0) +M:System.Collections.Immutable.ImmutableArray`1.AddRange(`0[]) +M:System.Collections.Immutable.ImmutableArray`1.AddRange(`0[],System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Immutable.ImmutableArray{`0},System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.ReadOnlySpan{`0}) +M:System.Collections.Immutable.ImmutableArray`1.AddRange``1(``0[]) +M:System.Collections.Immutable.ImmutableArray`1.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Collections.Immutable.ImmutableArray`1.As``1 +M:System.Collections.Immutable.ImmutableArray`1.AsMemory +M:System.Collections.Immutable.ImmutableArray`1.AsSpan +M:System.Collections.Immutable.ImmutableArray`1.AsSpan(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.AsSpan(System.Range) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Add(`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(`0[]) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(`0[],System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0},System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0}.Builder) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.ReadOnlySpan{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(``0[]) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Clear +M:System.Collections.Immutable.ImmutableArray`1.Builder.Contains(`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(`0[]) +M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(`0[],System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(System.Span{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.DrainToImmutable +M:System.Collections.Immutable.ImmutableArray`1.Builder.get_Capacity +M:System.Collections.Immutable.ImmutableArray`1.Builder.get_Count +M:System.Collections.Immutable.ImmutableArray`1.Builder.get_Item(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.GetEnumerator +M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Insert(System.Int32,`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.InsertRange(System.Int32,System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.ItemRef(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.MoveToImmutable +M:System.Collections.Immutable.ImmutableArray`1.Builder.Remove(`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveAt(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Replace(`0,`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Reverse +M:System.Collections.Immutable.ImmutableArray`1.Builder.set_Capacity(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.set_Count(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Builder.set_Item(System.Int32,`0) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort +M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Comparison{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Builder.ToArray +M:System.Collections.Immutable.ImmutableArray`1.Builder.ToImmutable +M:System.Collections.Immutable.ImmutableArray`1.CastArray``1 +M:System.Collections.Immutable.ImmutableArray`1.CastUp``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Collections.Immutable.ImmutableArray`1.Clear +M:System.Collections.Immutable.ImmutableArray`1.Contains(`0) +M:System.Collections.Immutable.ImmutableArray`1.Contains(`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.CopyTo(`0[]) +M:System.Collections.Immutable.ImmutableArray`1.CopyTo(`0[],System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.CopyTo(System.Span{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableArray`1.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableArray`1.Equals(System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Equals(System.Object) +M:System.Collections.Immutable.ImmutableArray`1.get_IsDefault +M:System.Collections.Immutable.ImmutableArray`1.get_IsDefaultOrEmpty +M:System.Collections.Immutable.ImmutableArray`1.get_IsEmpty +M:System.Collections.Immutable.ImmutableArray`1.get_Item(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.get_Length +M:System.Collections.Immutable.ImmutableArray`1.GetEnumerator +M:System.Collections.Immutable.ImmutableArray`1.GetHashCode +M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0) +M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Insert(System.Int32,`0) +M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,`0[]) +M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.ReadOnlySpan{`0}) +M:System.Collections.Immutable.ImmutableArray`1.ItemRef(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0) +M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.OfType``1 +M:System.Collections.Immutable.ImmutableArray`1.op_Equality(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.op_Equality(System.Nullable{System.Collections.Immutable.ImmutableArray{`0}},System.Nullable{System.Collections.Immutable.ImmutableArray{`0}}) +M:System.Collections.Immutable.ImmutableArray`1.op_Inequality(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.op_Inequality(System.Nullable{System.Collections.Immutable.ImmutableArray{`0}},System.Nullable{System.Collections.Immutable.ImmutableArray{`0}}) +M:System.Collections.Immutable.ImmutableArray`1.Remove(`0) +M:System.Collections.Immutable.ImmutableArray`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveAt(System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(`0[],System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Immutable.ImmutableArray{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.ReadOnlySpan{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Replace(`0,`0) +M:System.Collections.Immutable.ImmutableArray`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.SetItem(System.Int32,`0) +M:System.Collections.Immutable.ImmutableArray`1.Slice(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableArray`1.Sort +M:System.Collections.Immutable.ImmutableArray`1.Sort(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Sort(System.Comparison{`0}) +M:System.Collections.Immutable.ImmutableArray`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableArray`1.ToBuilder +M:System.Collections.Immutable.ImmutableDictionary.Contains``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0,``1) +M:System.Collections.Immutable.ImmutableDictionary.Create``2 +M:System.Collections.Immutable.ImmutableDictionary.Create``2(System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableDictionary.Create``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2 +M:System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2(System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableDictionary.GetValueOrDefault``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0) +M:System.Collections.Immutable.ImmutableDictionary.GetValueOrDefault``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0,``1) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}.Builder) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEqualityComparer{``2}) +M:System.Collections.Immutable.ImmutableDictionary`2.Add(`0,`1) +M:System.Collections.Immutable.ImmutableDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Add(`0,`1) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Add(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Clear +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.ContainsKey(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.ContainsValue(`1) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Count +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Item(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_KeyComparer +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Keys +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_ValueComparer +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Values +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.GetEnumerator +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.GetValueOrDefault(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.GetValueOrDefault(`0,`1) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Remove(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Remove(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.set_Item(`0,`1) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.set_KeyComparer(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.set_ValueComparer(System.Collections.Generic.IEqualityComparer{`1}) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.ToImmutable +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.TryGetKey(`0,`0@) +M:System.Collections.Immutable.ImmutableDictionary`2.Builder.TryGetValue(`0,`1@) +M:System.Collections.Immutable.ImmutableDictionary`2.Clear +M:System.Collections.Immutable.ImmutableDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableDictionary`2.ContainsKey(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.ContainsValue(`1) +M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.Dispose +M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.Reset +M:System.Collections.Immutable.ImmutableDictionary`2.get_Count +M:System.Collections.Immutable.ImmutableDictionary`2.get_IsEmpty +M:System.Collections.Immutable.ImmutableDictionary`2.get_Item(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.get_KeyComparer +M:System.Collections.Immutable.ImmutableDictionary`2.get_Keys +M:System.Collections.Immutable.ImmutableDictionary`2.get_ValueComparer +M:System.Collections.Immutable.ImmutableDictionary`2.get_Values +M:System.Collections.Immutable.ImmutableDictionary`2.GetEnumerator +M:System.Collections.Immutable.ImmutableDictionary`2.Remove(`0) +M:System.Collections.Immutable.ImmutableDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableDictionary`2.SetItem(`0,`1) +M:System.Collections.Immutable.ImmutableDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.ImmutableDictionary`2.ToBuilder +M:System.Collections.Immutable.ImmutableDictionary`2.TryGetKey(`0,`0@) +M:System.Collections.Immutable.ImmutableDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Immutable.ImmutableDictionary`2.WithComparers(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableDictionary`2.WithComparers(System.Collections.Generic.IEqualityComparer{`0},System.Collections.Generic.IEqualityComparer{`1}) +M:System.Collections.Immutable.ImmutableHashSet.Create``1 +M:System.Collections.Immutable.ImmutableHashSet.Create``1(``0) +M:System.Collections.Immutable.ImmutableHashSet.Create``1(``0[]) +M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},``0) +M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},``0[]) +M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableHashSet.CreateBuilder``1 +M:System.Collections.Immutable.ImmutableHashSet.CreateBuilder``1(System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableHashSet.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableHashSet.CreateRange``1(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Immutable.ImmutableHashSet{``0}.Builder) +M:System.Collections.Immutable.ImmutableHashSet`1.Add(`0) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Add(`0) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Clear +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Contains(`0) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.get_Count +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.get_KeyComparer +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.GetEnumerator +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Remove(`0) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.set_KeyComparer(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.ToImmutable +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.TryGetValue(`0,`0@) +M:System.Collections.Immutable.ImmutableHashSet`1.Builder.UnionWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Clear +M:System.Collections.Immutable.ImmutableHashSet`1.Contains(`0) +M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.Dispose +M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.Reset +M:System.Collections.Immutable.ImmutableHashSet`1.Except(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.get_Count +M:System.Collections.Immutable.ImmutableHashSet`1.get_IsEmpty +M:System.Collections.Immutable.ImmutableHashSet`1.get_KeyComparer +M:System.Collections.Immutable.ImmutableHashSet`1.GetEnumerator +M:System.Collections.Immutable.ImmutableHashSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.Remove(`0) +M:System.Collections.Immutable.ImmutableHashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.ToBuilder +M:System.Collections.Immutable.ImmutableHashSet`1.TryGetValue(`0,`0@) +M:System.Collections.Immutable.ImmutableHashSet`1.Union(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableHashSet`1.WithComparer(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableInterlocked.AddOrUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1,System.Func{``0,``1,``1}) +M:System.Collections.Immutable.ImmutableInterlocked.AddOrUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``1},System.Func{``0,``1,``1}) +M:System.Collections.Immutable.ImmutableInterlocked.Enqueue``1(System.Collections.Immutable.ImmutableQueue{``0}@,``0) +M:System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1) +M:System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``1}) +M:System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``3(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``2,``1},``2) +M:System.Collections.Immutable.ImmutableInterlocked.InterlockedCompareExchange``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0},System.Collections.Immutable.ImmutableArray{``0}) +M:System.Collections.Immutable.ImmutableInterlocked.InterlockedExchange``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0}) +M:System.Collections.Immutable.ImmutableInterlocked.InterlockedInitialize``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0}) +M:System.Collections.Immutable.ImmutableInterlocked.Push``1(System.Collections.Immutable.ImmutableStack{``0}@,``0) +M:System.Collections.Immutable.ImmutableInterlocked.TryAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1) +M:System.Collections.Immutable.ImmutableInterlocked.TryDequeue``1(System.Collections.Immutable.ImmutableQueue{``0}@,``0@) +M:System.Collections.Immutable.ImmutableInterlocked.TryPop``1(System.Collections.Immutable.ImmutableStack{``0}@,``0@) +M:System.Collections.Immutable.ImmutableInterlocked.TryRemove``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1@) +M:System.Collections.Immutable.ImmutableInterlocked.TryUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1,``1) +M:System.Collections.Immutable.ImmutableInterlocked.Update``1(``0@,System.Func{``0,``0}) +M:System.Collections.Immutable.ImmutableInterlocked.Update``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Func{System.Collections.Immutable.ImmutableArray{``0},System.Collections.Immutable.ImmutableArray{``0}}) +M:System.Collections.Immutable.ImmutableInterlocked.Update``2(``0@,System.Func{``0,``1,``0},``1) +M:System.Collections.Immutable.ImmutableInterlocked.Update``2(System.Collections.Immutable.ImmutableArray{``0}@,System.Func{System.Collections.Immutable.ImmutableArray{``0},``1,System.Collections.Immutable.ImmutableArray{``0}},``1) +M:System.Collections.Immutable.ImmutableList.Create``1 +M:System.Collections.Immutable.ImmutableList.Create``1(``0) +M:System.Collections.Immutable.ImmutableList.Create``1(``0[]) +M:System.Collections.Immutable.ImmutableList.Create``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableList.CreateBuilder``1 +M:System.Collections.Immutable.ImmutableList.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0) +M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32) +M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0) +M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) +M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32) +M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList.Remove``1(System.Collections.Immutable.IImmutableList{``0},``0) +M:System.Collections.Immutable.ImmutableList.RemoveRange``1(System.Collections.Immutable.IImmutableList{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableList.Replace``1(System.Collections.Immutable.IImmutableList{``0},``0,``0) +M:System.Collections.Immutable.ImmutableList.ToImmutableList``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableList.ToImmutableList``1(System.Collections.Immutable.ImmutableList{``0}.Builder) +M:System.Collections.Immutable.ImmutableList`1.Add(`0) +M:System.Collections.Immutable.ImmutableList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableList`1.BinarySearch(`0) +M:System.Collections.Immutable.ImmutableList`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Add(`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Clear +M:System.Collections.Immutable.ImmutableList`1.Builder.Contains(`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.ConvertAll``1(System.Func{`0,``0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(`0[]) +M:System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(`0[],System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.Exists(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Find(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindLast(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.ForEach(System.Action{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.get_Count +M:System.Collections.Immutable.ImmutableList`1.Builder.get_Item(System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.GetEnumerator +M:System.Collections.Immutable.ImmutableList`1.Builder.GetRange(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Insert(System.Int32,`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.ItemRef(System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Remove(`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveAt(System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.Replace(`0,`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Reverse +M:System.Collections.Immutable.ImmutableList`1.Builder.Reverse(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Builder.set_Item(System.Int32,`0) +M:System.Collections.Immutable.ImmutableList`1.Builder.Sort +M:System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Comparison{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Builder.ToImmutable +M:System.Collections.Immutable.ImmutableList`1.Builder.TrueForAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Clear +M:System.Collections.Immutable.ImmutableList`1.Contains(`0) +M:System.Collections.Immutable.ImmutableList`1.ConvertAll``1(System.Func{`0,``0}) +M:System.Collections.Immutable.ImmutableList`1.CopyTo(`0[]) +M:System.Collections.Immutable.ImmutableList`1.CopyTo(`0[],System.Int32) +M:System.Collections.Immutable.ImmutableList`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Enumerator.Dispose +M:System.Collections.Immutable.ImmutableList`1.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableList`1.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableList`1.Enumerator.Reset +M:System.Collections.Immutable.ImmutableList`1.Exists(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.Find(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindIndex(System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindIndex(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindLast(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Int32,System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.ForEach(System.Action{`0}) +M:System.Collections.Immutable.ImmutableList`1.get_Count +M:System.Collections.Immutable.ImmutableList`1.get_IsEmpty +M:System.Collections.Immutable.ImmutableList`1.get_Item(System.Int32) +M:System.Collections.Immutable.ImmutableList`1.GetEnumerator +M:System.Collections.Immutable.ImmutableList`1.GetRange(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.IndexOf(`0) +M:System.Collections.Immutable.ImmutableList`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Insert(System.Int32,`0) +M:System.Collections.Immutable.ImmutableList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableList`1.ItemRef(System.Int32) +M:System.Collections.Immutable.ImmutableList`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Remove(`0) +M:System.Collections.Immutable.ImmutableList`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.RemoveAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableList`1.RemoveAt(System.Int32) +M:System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.Replace(`0,`0) +M:System.Collections.Immutable.ImmutableList`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Reverse +M:System.Collections.Immutable.ImmutableList`1.Reverse(System.Int32,System.Int32) +M:System.Collections.Immutable.ImmutableList`1.SetItem(System.Int32,`0) +M:System.Collections.Immutable.ImmutableList`1.Sort +M:System.Collections.Immutable.ImmutableList`1.Sort(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.Sort(System.Comparison{`0}) +M:System.Collections.Immutable.ImmutableList`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableList`1.ToBuilder +M:System.Collections.Immutable.ImmutableList`1.TrueForAll(System.Predicate{`0}) +M:System.Collections.Immutable.ImmutableQueue.Create``1 +M:System.Collections.Immutable.ImmutableQueue.Create``1(``0) +M:System.Collections.Immutable.ImmutableQueue.Create``1(``0[]) +M:System.Collections.Immutable.ImmutableQueue.Create``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableQueue.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableQueue.Dequeue``1(System.Collections.Immutable.IImmutableQueue{``0},``0@) +M:System.Collections.Immutable.ImmutableQueue`1.Clear +M:System.Collections.Immutable.ImmutableQueue`1.Dequeue +M:System.Collections.Immutable.ImmutableQueue`1.Dequeue(`0@) +M:System.Collections.Immutable.ImmutableQueue`1.Enqueue(`0) +M:System.Collections.Immutable.ImmutableQueue`1.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableQueue`1.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableQueue`1.get_Empty +M:System.Collections.Immutable.ImmutableQueue`1.get_IsEmpty +M:System.Collections.Immutable.ImmutableQueue`1.GetEnumerator +M:System.Collections.Immutable.ImmutableQueue`1.Peek +M:System.Collections.Immutable.ImmutableQueue`1.PeekRef +M:System.Collections.Immutable.ImmutableSortedDictionary.Create``2 +M:System.Collections.Immutable.ImmutableSortedDictionary.Create``2(System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableSortedDictionary.Create``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2 +M:System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2(System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Immutable.ImmutableSortedDictionary{``0,``1}.Builder) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IComparer{``1}) +M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IComparer{``1},System.Collections.Generic.IEqualityComparer{``2}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Add(`0,`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Add(`0,`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Add(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Clear +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ContainsKey(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ContainsValue(`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Count +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Item(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_KeyComparer +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Keys +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_ValueComparer +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Values +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetEnumerator +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetValueOrDefault(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetValueOrDefault(`0,`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Remove(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Remove(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_Item(`0,`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_KeyComparer(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_ValueComparer(System.Collections.Generic.IEqualityComparer{`1}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ToImmutable +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.TryGetKey(`0,`0@) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.TryGetValue(`0,`1@) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ValueRef(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Clear +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.ContainsKey(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.ContainsValue(`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.Dispose +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.Reset +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Count +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_IsEmpty +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Item(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_KeyComparer +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Keys +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_ValueComparer +M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Values +M:System.Collections.Immutable.ImmutableSortedDictionary`2.GetEnumerator +M:System.Collections.Immutable.ImmutableSortedDictionary`2.Remove(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.SetItem(`0,`1) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.ToBuilder +M:System.Collections.Immutable.ImmutableSortedDictionary`2.TryGetKey(`0,`0@) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.ValueRef(`0) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.WithComparers(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableSortedDictionary`2.WithComparers(System.Collections.Generic.IComparer{`0},System.Collections.Generic.IEqualityComparer{`1}) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1 +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(``0) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(``0[]) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},``0) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},``0[]) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.CreateBuilder``1 +M:System.Collections.Immutable.ImmutableSortedSet.CreateBuilder``1(System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.CreateRange``1(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +M:System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Immutable.ImmutableSortedSet{``0}.Builder) +M:System.Collections.Immutable.ImmutableSortedSet`1.Add(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Add(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Clear +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Contains(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Count +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Item(System.Int32) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_KeyComparer +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Max +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Min +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.GetEnumerator +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IndexOf(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.ItemRef(System.Int32) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Remove(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Reverse +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.set_KeyComparer(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.ToImmutable +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.TryGetValue(`0,`0@) +M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.UnionWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Clear +M:System.Collections.Immutable.ImmutableSortedSet`1.Contains(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.Dispose +M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.Reset +M:System.Collections.Immutable.ImmutableSortedSet`1.Except(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.get_Count +M:System.Collections.Immutable.ImmutableSortedSet`1.get_IsEmpty +M:System.Collections.Immutable.ImmutableSortedSet`1.get_Item(System.Int32) +M:System.Collections.Immutable.ImmutableSortedSet`1.get_KeyComparer +M:System.Collections.Immutable.ImmutableSortedSet`1.get_Max +M:System.Collections.Immutable.ImmutableSortedSet`1.get_Min +M:System.Collections.Immutable.ImmutableSortedSet`1.GetEnumerator +M:System.Collections.Immutable.ImmutableSortedSet`1.IndexOf(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.ItemRef(System.Int32) +M:System.Collections.Immutable.ImmutableSortedSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.Remove(`0) +M:System.Collections.Immutable.ImmutableSortedSet`1.Reverse +M:System.Collections.Immutable.ImmutableSortedSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.ToBuilder +M:System.Collections.Immutable.ImmutableSortedSet`1.TryGetValue(`0,`0@) +M:System.Collections.Immutable.ImmutableSortedSet`1.Union(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Immutable.ImmutableSortedSet`1.WithComparer(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Immutable.ImmutableStack.Create``1 +M:System.Collections.Immutable.ImmutableStack.Create``1(``0) +M:System.Collections.Immutable.ImmutableStack.Create``1(``0[]) +M:System.Collections.Immutable.ImmutableStack.Create``1(System.ReadOnlySpan{``0}) +M:System.Collections.Immutable.ImmutableStack.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Collections.Immutable.ImmutableStack.Pop``1(System.Collections.Immutable.IImmutableStack{``0},``0@) +M:System.Collections.Immutable.ImmutableStack`1.Clear +M:System.Collections.Immutable.ImmutableStack`1.Enumerator.get_Current +M:System.Collections.Immutable.ImmutableStack`1.Enumerator.MoveNext +M:System.Collections.Immutable.ImmutableStack`1.get_Empty +M:System.Collections.Immutable.ImmutableStack`1.get_IsEmpty +M:System.Collections.Immutable.ImmutableStack`1.GetEnumerator +M:System.Collections.Immutable.ImmutableStack`1.Peek +M:System.Collections.Immutable.ImmutableStack`1.PeekRef +M:System.Collections.Immutable.ImmutableStack`1.Pop +M:System.Collections.Immutable.ImmutableStack`1.Pop(`0@) +M:System.Collections.Immutable.ImmutableStack`1.Push(`0) +M:System.Linq.ImmutableArrayExtensions.Aggregate``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``0,``0}) +M:System.Linq.ImmutableArrayExtensions.Aggregate``2(System.Collections.Immutable.ImmutableArray{``1},``0,System.Func{``0,``1,``0}) +M:System.Linq.ImmutableArrayExtensions.Aggregate``3(System.Collections.Immutable.ImmutableArray{``2},``0,System.Func{``0,``2,``0},System.Func{``0,``1}) +M:System.Linq.ImmutableArrayExtensions.All``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Linq.ImmutableArrayExtensions.ElementAt``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32) +M:System.Linq.ImmutableArrayExtensions.ElementAtOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32) +M:System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) +M:System.Linq.ImmutableArrayExtensions.Select``2(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1}) +M:System.Linq.ImmutableArrayExtensions.SelectMany``3(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) +M:System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Immutable.ImmutableArray{``0},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Immutable.ImmutableArray{``0},System.Func{``1,``1,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.Single``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.Single``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.SingleOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.SingleOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Linq.ImmutableArrayExtensions.ToArray``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Linq.ImmutableArrayExtensions.ToDictionary``2(System.Collections.Immutable.ImmutableArray{``1},System.Func{``1,``0}) +M:System.Linq.ImmutableArrayExtensions.ToDictionary``2(System.Collections.Immutable.ImmutableArray{``1},System.Func{``1,``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.ImmutableArrayExtensions.ToDictionary``3(System.Collections.Immutable.ImmutableArray{``2},System.Func{``2,``0},System.Func{``2,``1}) +M:System.Linq.ImmutableArrayExtensions.ToDictionary``3(System.Collections.Immutable.ImmutableArray{``2},System.Func{``2,``0},System.Func{``2,``1},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.ImmutableArrayExtensions.Where``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) +M:System.Runtime.InteropServices.ImmutableCollectionsMarshal.AsArray``1(System.Collections.Immutable.ImmutableArray{``0}) +M:System.Runtime.InteropServices.ImmutableCollectionsMarshal.AsImmutableArray``1(``0[]) +T:System.Collections.Frozen.FrozenDictionary +T:System.Collections.Frozen.FrozenDictionary`2 +T:System.Collections.Frozen.FrozenDictionary`2.Enumerator +T:System.Collections.Frozen.FrozenSet +T:System.Collections.Frozen.FrozenSet`1 +T:System.Collections.Frozen.FrozenSet`1.Enumerator +T:System.Collections.Immutable.IImmutableDictionary`2 +T:System.Collections.Immutable.IImmutableList`1 +T:System.Collections.Immutable.IImmutableQueue`1 +T:System.Collections.Immutable.IImmutableSet`1 +T:System.Collections.Immutable.IImmutableStack`1 +T:System.Collections.Immutable.ImmutableArray +T:System.Collections.Immutable.ImmutableArray`1 +T:System.Collections.Immutable.ImmutableArray`1.Builder +T:System.Collections.Immutable.ImmutableArray`1.Enumerator +T:System.Collections.Immutable.ImmutableDictionary +T:System.Collections.Immutable.ImmutableDictionary`2 +T:System.Collections.Immutable.ImmutableDictionary`2.Builder +T:System.Collections.Immutable.ImmutableDictionary`2.Enumerator +T:System.Collections.Immutable.ImmutableHashSet +T:System.Collections.Immutable.ImmutableHashSet`1 +T:System.Collections.Immutable.ImmutableHashSet`1.Builder +T:System.Collections.Immutable.ImmutableHashSet`1.Enumerator +T:System.Collections.Immutable.ImmutableInterlocked +T:System.Collections.Immutable.ImmutableList +T:System.Collections.Immutable.ImmutableList`1 +T:System.Collections.Immutable.ImmutableList`1.Builder +T:System.Collections.Immutable.ImmutableList`1.Enumerator +T:System.Collections.Immutable.ImmutableQueue +T:System.Collections.Immutable.ImmutableQueue`1 +T:System.Collections.Immutable.ImmutableQueue`1.Enumerator +T:System.Collections.Immutable.ImmutableSortedDictionary +T:System.Collections.Immutable.ImmutableSortedDictionary`2 +T:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder +T:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator +T:System.Collections.Immutable.ImmutableSortedSet +T:System.Collections.Immutable.ImmutableSortedSet`1 +T:System.Collections.Immutable.ImmutableSortedSet`1.Builder +T:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator +T:System.Collections.Immutable.ImmutableStack +T:System.Collections.Immutable.ImmutableStack`1 +T:System.Collections.Immutable.ImmutableStack`1.Enumerator +T:System.Linq.ImmutableArrayExtensions +T:System.Runtime.InteropServices.ImmutableCollectionsMarshal \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt new file mode 100644 index 0000000000000..6476ecccd5041 --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt @@ -0,0 +1,431 @@ +M:System.Collections.BitArray.#ctor(System.Boolean[]) +M:System.Collections.BitArray.#ctor(System.Byte[]) +M:System.Collections.BitArray.#ctor(System.Collections.BitArray) +M:System.Collections.BitArray.#ctor(System.Int32) +M:System.Collections.BitArray.#ctor(System.Int32,System.Boolean) +M:System.Collections.BitArray.#ctor(System.Int32[]) +M:System.Collections.BitArray.And(System.Collections.BitArray) +M:System.Collections.BitArray.Clone +M:System.Collections.BitArray.CopyTo(System.Array,System.Int32) +M:System.Collections.BitArray.Get(System.Int32) +M:System.Collections.BitArray.get_Count +M:System.Collections.BitArray.get_IsReadOnly +M:System.Collections.BitArray.get_IsSynchronized +M:System.Collections.BitArray.get_Item(System.Int32) +M:System.Collections.BitArray.get_Length +M:System.Collections.BitArray.get_SyncRoot +M:System.Collections.BitArray.GetEnumerator +M:System.Collections.BitArray.HasAllSet +M:System.Collections.BitArray.HasAnySet +M:System.Collections.BitArray.LeftShift(System.Int32) +M:System.Collections.BitArray.Not +M:System.Collections.BitArray.Or(System.Collections.BitArray) +M:System.Collections.BitArray.RightShift(System.Int32) +M:System.Collections.BitArray.Set(System.Int32,System.Boolean) +M:System.Collections.BitArray.set_Item(System.Int32,System.Boolean) +M:System.Collections.BitArray.set_Length(System.Int32) +M:System.Collections.BitArray.SetAll(System.Boolean) +M:System.Collections.BitArray.Xor(System.Collections.BitArray) +M:System.Collections.Generic.CollectionExtensions.AddRange``1(System.Collections.Generic.List{``0},System.ReadOnlySpan{``0}) +M:System.Collections.Generic.CollectionExtensions.AsReadOnly``1(System.Collections.Generic.IList{``0}) +M:System.Collections.Generic.CollectionExtensions.AsReadOnly``2(System.Collections.Generic.IDictionary{``0,``1}) +M:System.Collections.Generic.CollectionExtensions.CopyTo``1(System.Collections.Generic.List{``0},System.Span{``0}) +M:System.Collections.Generic.CollectionExtensions.GetValueOrDefault``2(System.Collections.Generic.IReadOnlyDictionary{``0,``1},``0) +M:System.Collections.Generic.CollectionExtensions.GetValueOrDefault``2(System.Collections.Generic.IReadOnlyDictionary{``0,``1},``0,``1) +M:System.Collections.Generic.CollectionExtensions.InsertRange``1(System.Collections.Generic.List{``0},System.Int32,System.ReadOnlySpan{``0}) +M:System.Collections.Generic.CollectionExtensions.Remove``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1@) +M:System.Collections.Generic.CollectionExtensions.TryAdd``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1) +M:System.Collections.Generic.Comparer`1.#ctor +M:System.Collections.Generic.Comparer`1.Compare(`0,`0) +M:System.Collections.Generic.Comparer`1.Create(System.Comparison{`0}) +M:System.Collections.Generic.Comparer`1.get_Default +M:System.Collections.Generic.Dictionary`2.#ctor +M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Int32) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.Dictionary`2.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.Dictionary`2.Add(`0,`1) +M:System.Collections.Generic.Dictionary`2.Clear +M:System.Collections.Generic.Dictionary`2.ContainsKey(`0) +M:System.Collections.Generic.Dictionary`2.ContainsValue(`1) +M:System.Collections.Generic.Dictionary`2.EnsureCapacity(System.Int32) +M:System.Collections.Generic.Dictionary`2.Enumerator.Dispose +M:System.Collections.Generic.Dictionary`2.Enumerator.get_Current +M:System.Collections.Generic.Dictionary`2.Enumerator.MoveNext +M:System.Collections.Generic.Dictionary`2.get_Comparer +M:System.Collections.Generic.Dictionary`2.get_Count +M:System.Collections.Generic.Dictionary`2.get_Item(`0) +M:System.Collections.Generic.Dictionary`2.get_Keys +M:System.Collections.Generic.Dictionary`2.get_Values +M:System.Collections.Generic.Dictionary`2.GetEnumerator +M:System.Collections.Generic.Dictionary`2.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.Dictionary`2.KeyCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) +M:System.Collections.Generic.Dictionary`2.KeyCollection.Contains(`0) +M:System.Collections.Generic.Dictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.Dispose +M:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.get_Current +M:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.MoveNext +M:System.Collections.Generic.Dictionary`2.KeyCollection.get_Count +M:System.Collections.Generic.Dictionary`2.KeyCollection.GetEnumerator +M:System.Collections.Generic.Dictionary`2.OnDeserialization(System.Object) +M:System.Collections.Generic.Dictionary`2.Remove(`0) +M:System.Collections.Generic.Dictionary`2.Remove(`0,`1@) +M:System.Collections.Generic.Dictionary`2.set_Item(`0,`1) +M:System.Collections.Generic.Dictionary`2.TrimExcess +M:System.Collections.Generic.Dictionary`2.TrimExcess(System.Int32) +M:System.Collections.Generic.Dictionary`2.TryAdd(`0,`1) +M:System.Collections.Generic.Dictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Generic.Dictionary`2.ValueCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) +M:System.Collections.Generic.Dictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +M:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.Dispose +M:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.get_Current +M:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.MoveNext +M:System.Collections.Generic.Dictionary`2.ValueCollection.get_Count +M:System.Collections.Generic.Dictionary`2.ValueCollection.GetEnumerator +M:System.Collections.Generic.EqualityComparer`1.#ctor +M:System.Collections.Generic.EqualityComparer`1.Create(System.Func{`0,`0,System.Boolean},System.Func{`0,System.Int32}) +M:System.Collections.Generic.EqualityComparer`1.Equals(`0,`0) +M:System.Collections.Generic.EqualityComparer`1.get_Default +M:System.Collections.Generic.EqualityComparer`1.GetHashCode(`0) +M:System.Collections.Generic.HashSet`1.#ctor +M:System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.HashSet`1.#ctor(System.Int32) +M:System.Collections.Generic.HashSet`1.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.HashSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.HashSet`1.Add(`0) +M:System.Collections.Generic.HashSet`1.Clear +M:System.Collections.Generic.HashSet`1.Contains(`0) +M:System.Collections.Generic.HashSet`1.CopyTo(`0[]) +M:System.Collections.Generic.HashSet`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.HashSet`1.CopyTo(`0[],System.Int32,System.Int32) +M:System.Collections.Generic.HashSet`1.CreateSetComparer +M:System.Collections.Generic.HashSet`1.EnsureCapacity(System.Int32) +M:System.Collections.Generic.HashSet`1.Enumerator.Dispose +M:System.Collections.Generic.HashSet`1.Enumerator.get_Current +M:System.Collections.Generic.HashSet`1.Enumerator.MoveNext +M:System.Collections.Generic.HashSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.get_Comparer +M:System.Collections.Generic.HashSet`1.get_Count +M:System.Collections.Generic.HashSet`1.GetEnumerator +M:System.Collections.Generic.HashSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.HashSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.OnDeserialization(System.Object) +M:System.Collections.Generic.HashSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.Remove(`0) +M:System.Collections.Generic.HashSet`1.RemoveWhere(System.Predicate{`0}) +M:System.Collections.Generic.HashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.HashSet`1.TrimExcess +M:System.Collections.Generic.HashSet`1.TryGetValue(`0,`0@) +M:System.Collections.Generic.HashSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.LinkedList`1.#ctor +M:System.Collections.Generic.LinkedList`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.LinkedList`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.LinkedList`1.AddAfter(System.Collections.Generic.LinkedListNode{`0},`0) +M:System.Collections.Generic.LinkedList`1.AddAfter(System.Collections.Generic.LinkedListNode{`0},System.Collections.Generic.LinkedListNode{`0}) +M:System.Collections.Generic.LinkedList`1.AddBefore(System.Collections.Generic.LinkedListNode{`0},`0) +M:System.Collections.Generic.LinkedList`1.AddBefore(System.Collections.Generic.LinkedListNode{`0},System.Collections.Generic.LinkedListNode{`0}) +M:System.Collections.Generic.LinkedList`1.AddFirst(`0) +M:System.Collections.Generic.LinkedList`1.AddFirst(System.Collections.Generic.LinkedListNode{`0}) +M:System.Collections.Generic.LinkedList`1.AddLast(`0) +M:System.Collections.Generic.LinkedList`1.AddLast(System.Collections.Generic.LinkedListNode{`0}) +M:System.Collections.Generic.LinkedList`1.Clear +M:System.Collections.Generic.LinkedList`1.Contains(`0) +M:System.Collections.Generic.LinkedList`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.LinkedList`1.Enumerator.Dispose +M:System.Collections.Generic.LinkedList`1.Enumerator.get_Current +M:System.Collections.Generic.LinkedList`1.Enumerator.MoveNext +M:System.Collections.Generic.LinkedList`1.Find(`0) +M:System.Collections.Generic.LinkedList`1.FindLast(`0) +M:System.Collections.Generic.LinkedList`1.get_Count +M:System.Collections.Generic.LinkedList`1.get_First +M:System.Collections.Generic.LinkedList`1.get_Last +M:System.Collections.Generic.LinkedList`1.GetEnumerator +M:System.Collections.Generic.LinkedList`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.LinkedList`1.OnDeserialization(System.Object) +M:System.Collections.Generic.LinkedList`1.Remove(`0) +M:System.Collections.Generic.LinkedList`1.Remove(System.Collections.Generic.LinkedListNode{`0}) +M:System.Collections.Generic.LinkedList`1.RemoveFirst +M:System.Collections.Generic.LinkedList`1.RemoveLast +M:System.Collections.Generic.LinkedListNode`1.#ctor(`0) +M:System.Collections.Generic.LinkedListNode`1.get_List +M:System.Collections.Generic.LinkedListNode`1.get_Next +M:System.Collections.Generic.LinkedListNode`1.get_Previous +M:System.Collections.Generic.LinkedListNode`1.get_Value +M:System.Collections.Generic.LinkedListNode`1.get_ValueRef +M:System.Collections.Generic.LinkedListNode`1.set_Value(`0) +M:System.Collections.Generic.List`1.#ctor +M:System.Collections.Generic.List`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.List`1.#ctor(System.Int32) +M:System.Collections.Generic.List`1.Add(`0) +M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.List`1.AsReadOnly +M:System.Collections.Generic.List`1.BinarySearch(`0) +M:System.Collections.Generic.List`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.List`1.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.List`1.Clear +M:System.Collections.Generic.List`1.Contains(`0) +M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0}) +M:System.Collections.Generic.List`1.CopyTo(`0[]) +M:System.Collections.Generic.List`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.List`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) +M:System.Collections.Generic.List`1.EnsureCapacity(System.Int32) +M:System.Collections.Generic.List`1.Enumerator.Dispose +M:System.Collections.Generic.List`1.Enumerator.get_Current +M:System.Collections.Generic.List`1.Enumerator.MoveNext +M:System.Collections.Generic.List`1.Exists(System.Predicate{`0}) +M:System.Collections.Generic.List`1.Find(System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindAll(System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindIndex(System.Int32,System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindIndex(System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindLast(System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindLastIndex(System.Int32,System.Predicate{`0}) +M:System.Collections.Generic.List`1.FindLastIndex(System.Predicate{`0}) +M:System.Collections.Generic.List`1.ForEach(System.Action{`0}) +M:System.Collections.Generic.List`1.get_Capacity +M:System.Collections.Generic.List`1.get_Count +M:System.Collections.Generic.List`1.get_Item(System.Int32) +M:System.Collections.Generic.List`1.GetEnumerator +M:System.Collections.Generic.List`1.GetRange(System.Int32,System.Int32) +M:System.Collections.Generic.List`1.IndexOf(`0) +M:System.Collections.Generic.List`1.IndexOf(`0,System.Int32) +M:System.Collections.Generic.List`1.IndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Generic.List`1.Insert(System.Int32,`0) +M:System.Collections.Generic.List`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.List`1.LastIndexOf(`0) +M:System.Collections.Generic.List`1.LastIndexOf(`0,System.Int32) +M:System.Collections.Generic.List`1.LastIndexOf(`0,System.Int32,System.Int32) +M:System.Collections.Generic.List`1.Remove(`0) +M:System.Collections.Generic.List`1.RemoveAll(System.Predicate{`0}) +M:System.Collections.Generic.List`1.RemoveAt(System.Int32) +M:System.Collections.Generic.List`1.RemoveRange(System.Int32,System.Int32) +M:System.Collections.Generic.List`1.Reverse +M:System.Collections.Generic.List`1.Reverse(System.Int32,System.Int32) +M:System.Collections.Generic.List`1.set_Capacity(System.Int32) +M:System.Collections.Generic.List`1.set_Item(System.Int32,`0) +M:System.Collections.Generic.List`1.Slice(System.Int32,System.Int32) +M:System.Collections.Generic.List`1.Sort +M:System.Collections.Generic.List`1.Sort(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.List`1.Sort(System.Comparison{`0}) +M:System.Collections.Generic.List`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.List`1.ToArray +M:System.Collections.Generic.List`1.TrimExcess +M:System.Collections.Generic.List`1.TrueForAll(System.Predicate{`0}) +M:System.Collections.Generic.PriorityQueue`2.#ctor +M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IComparer{`1}) +M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}}) +M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}},System.Collections.Generic.IComparer{`1}) +M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Int32) +M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Int32,System.Collections.Generic.IComparer{`1}) +M:System.Collections.Generic.PriorityQueue`2.Clear +M:System.Collections.Generic.PriorityQueue`2.Dequeue +M:System.Collections.Generic.PriorityQueue`2.DequeueEnqueue(`0,`1) +M:System.Collections.Generic.PriorityQueue`2.Enqueue(`0,`1) +M:System.Collections.Generic.PriorityQueue`2.EnqueueDequeue(`0,`1) +M:System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{`0},`1) +M:System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}}) +M:System.Collections.Generic.PriorityQueue`2.EnsureCapacity(System.Int32) +M:System.Collections.Generic.PriorityQueue`2.get_Comparer +M:System.Collections.Generic.PriorityQueue`2.get_Count +M:System.Collections.Generic.PriorityQueue`2.get_UnorderedItems +M:System.Collections.Generic.PriorityQueue`2.Peek +M:System.Collections.Generic.PriorityQueue`2.TrimExcess +M:System.Collections.Generic.PriorityQueue`2.TryDequeue(`0@,`1@) +M:System.Collections.Generic.PriorityQueue`2.TryPeek(`0@,`1@) +M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.Dispose +M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.get_Current +M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.MoveNext +M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.get_Count +M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.GetEnumerator +M:System.Collections.Generic.Queue`1.#ctor +M:System.Collections.Generic.Queue`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.Queue`1.#ctor(System.Int32) +M:System.Collections.Generic.Queue`1.Clear +M:System.Collections.Generic.Queue`1.Contains(`0) +M:System.Collections.Generic.Queue`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.Queue`1.Dequeue +M:System.Collections.Generic.Queue`1.Enqueue(`0) +M:System.Collections.Generic.Queue`1.EnsureCapacity(System.Int32) +M:System.Collections.Generic.Queue`1.Enumerator.Dispose +M:System.Collections.Generic.Queue`1.Enumerator.get_Current +M:System.Collections.Generic.Queue`1.Enumerator.MoveNext +M:System.Collections.Generic.Queue`1.get_Count +M:System.Collections.Generic.Queue`1.GetEnumerator +M:System.Collections.Generic.Queue`1.Peek +M:System.Collections.Generic.Queue`1.ToArray +M:System.Collections.Generic.Queue`1.TrimExcess +M:System.Collections.Generic.Queue`1.TryDequeue(`0@) +M:System.Collections.Generic.Queue`1.TryPeek(`0@) +M:System.Collections.Generic.ReferenceEqualityComparer.Equals(System.Object,System.Object) +M:System.Collections.Generic.ReferenceEqualityComparer.get_Instance +M:System.Collections.Generic.ReferenceEqualityComparer.GetHashCode(System.Object) +M:System.Collections.Generic.SortedDictionary`2.#ctor +M:System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +M:System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedDictionary`2.Add(`0,`1) +M:System.Collections.Generic.SortedDictionary`2.Clear +M:System.Collections.Generic.SortedDictionary`2.ContainsKey(`0) +M:System.Collections.Generic.SortedDictionary`2.ContainsValue(`1) +M:System.Collections.Generic.SortedDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) +M:System.Collections.Generic.SortedDictionary`2.Enumerator.Dispose +M:System.Collections.Generic.SortedDictionary`2.Enumerator.get_Current +M:System.Collections.Generic.SortedDictionary`2.Enumerator.MoveNext +M:System.Collections.Generic.SortedDictionary`2.get_Comparer +M:System.Collections.Generic.SortedDictionary`2.get_Count +M:System.Collections.Generic.SortedDictionary`2.get_Item(`0) +M:System.Collections.Generic.SortedDictionary`2.get_Keys +M:System.Collections.Generic.SortedDictionary`2.get_Values +M:System.Collections.Generic.SortedDictionary`2.GetEnumerator +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.#ctor(System.Collections.Generic.SortedDictionary{`0,`1}) +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Contains(`0) +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.Dispose +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.get_Current +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.MoveNext +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.get_Count +M:System.Collections.Generic.SortedDictionary`2.KeyCollection.GetEnumerator +M:System.Collections.Generic.SortedDictionary`2.Remove(`0) +M:System.Collections.Generic.SortedDictionary`2.set_Item(`0,`1) +M:System.Collections.Generic.SortedDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.#ctor(System.Collections.Generic.SortedDictionary{`0,`1}) +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.Dispose +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.get_Current +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.MoveNext +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.get_Count +M:System.Collections.Generic.SortedDictionary`2.ValueCollection.GetEnumerator +M:System.Collections.Generic.SortedList`2.#ctor +M:System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +M:System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedList`2.#ctor(System.Int32) +M:System.Collections.Generic.SortedList`2.#ctor(System.Int32,System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedList`2.Add(`0,`1) +M:System.Collections.Generic.SortedList`2.Clear +M:System.Collections.Generic.SortedList`2.ContainsKey(`0) +M:System.Collections.Generic.SortedList`2.ContainsValue(`1) +M:System.Collections.Generic.SortedList`2.get_Capacity +M:System.Collections.Generic.SortedList`2.get_Comparer +M:System.Collections.Generic.SortedList`2.get_Count +M:System.Collections.Generic.SortedList`2.get_Item(`0) +M:System.Collections.Generic.SortedList`2.get_Keys +M:System.Collections.Generic.SortedList`2.get_Values +M:System.Collections.Generic.SortedList`2.GetEnumerator +M:System.Collections.Generic.SortedList`2.GetKeyAtIndex(System.Int32) +M:System.Collections.Generic.SortedList`2.GetValueAtIndex(System.Int32) +M:System.Collections.Generic.SortedList`2.IndexOfKey(`0) +M:System.Collections.Generic.SortedList`2.IndexOfValue(`1) +M:System.Collections.Generic.SortedList`2.Remove(`0) +M:System.Collections.Generic.SortedList`2.RemoveAt(System.Int32) +M:System.Collections.Generic.SortedList`2.set_Capacity(System.Int32) +M:System.Collections.Generic.SortedList`2.set_Item(`0,`1) +M:System.Collections.Generic.SortedList`2.SetValueAtIndex(System.Int32,`1) +M:System.Collections.Generic.SortedList`2.TrimExcess +M:System.Collections.Generic.SortedList`2.TryGetValue(`0,`1@) +M:System.Collections.Generic.SortedSet`1.#ctor +M:System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IComparer{`0}) +M:System.Collections.Generic.SortedSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.SortedSet`1.Add(`0) +M:System.Collections.Generic.SortedSet`1.Clear +M:System.Collections.Generic.SortedSet`1.Contains(`0) +M:System.Collections.Generic.SortedSet`1.CopyTo(`0[]) +M:System.Collections.Generic.SortedSet`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.SortedSet`1.CopyTo(`0[],System.Int32,System.Int32) +M:System.Collections.Generic.SortedSet`1.CreateSetComparer +M:System.Collections.Generic.SortedSet`1.CreateSetComparer(System.Collections.Generic.IEqualityComparer{`0}) +M:System.Collections.Generic.SortedSet`1.Enumerator.Dispose +M:System.Collections.Generic.SortedSet`1.Enumerator.get_Current +M:System.Collections.Generic.SortedSet`1.Enumerator.MoveNext +M:System.Collections.Generic.SortedSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.get_Comparer +M:System.Collections.Generic.SortedSet`1.get_Count +M:System.Collections.Generic.SortedSet`1.get_Max +M:System.Collections.Generic.SortedSet`1.get_Min +M:System.Collections.Generic.SortedSet`1.GetEnumerator +M:System.Collections.Generic.SortedSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.SortedSet`1.GetViewBetween(`0,`0) +M:System.Collections.Generic.SortedSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.OnDeserialization(System.Object) +M:System.Collections.Generic.SortedSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.Remove(`0) +M:System.Collections.Generic.SortedSet`1.RemoveWhere(System.Predicate{`0}) +M:System.Collections.Generic.SortedSet`1.Reverse +M:System.Collections.Generic.SortedSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.SortedSet`1.TryGetValue(`0,`0@) +M:System.Collections.Generic.SortedSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.Stack`1.#ctor +M:System.Collections.Generic.Stack`1.#ctor(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.Stack`1.#ctor(System.Int32) +M:System.Collections.Generic.Stack`1.Clear +M:System.Collections.Generic.Stack`1.Contains(`0) +M:System.Collections.Generic.Stack`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.Stack`1.EnsureCapacity(System.Int32) +M:System.Collections.Generic.Stack`1.Enumerator.Dispose +M:System.Collections.Generic.Stack`1.Enumerator.get_Current +M:System.Collections.Generic.Stack`1.Enumerator.MoveNext +M:System.Collections.Generic.Stack`1.get_Count +M:System.Collections.Generic.Stack`1.GetEnumerator +M:System.Collections.Generic.Stack`1.Peek +M:System.Collections.Generic.Stack`1.Pop +M:System.Collections.Generic.Stack`1.Push(`0) +M:System.Collections.Generic.Stack`1.ToArray +M:System.Collections.Generic.Stack`1.TrimExcess +M:System.Collections.Generic.Stack`1.TryPeek(`0@) +M:System.Collections.Generic.Stack`1.TryPop(`0@) +M:System.Collections.StructuralComparisons.get_StructuralComparer +M:System.Collections.StructuralComparisons.get_StructuralEqualityComparer +T:System.Collections.BitArray +T:System.Collections.Generic.CollectionExtensions +T:System.Collections.Generic.Comparer`1 +T:System.Collections.Generic.Dictionary`2 +T:System.Collections.Generic.Dictionary`2.Enumerator +T:System.Collections.Generic.Dictionary`2.KeyCollection +T:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator +T:System.Collections.Generic.Dictionary`2.ValueCollection +T:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator +T:System.Collections.Generic.EqualityComparer`1 +T:System.Collections.Generic.HashSet`1 +T:System.Collections.Generic.HashSet`1.Enumerator +T:System.Collections.Generic.LinkedList`1 +T:System.Collections.Generic.LinkedList`1.Enumerator +T:System.Collections.Generic.LinkedListNode`1 +T:System.Collections.Generic.List`1 +T:System.Collections.Generic.List`1.Enumerator +T:System.Collections.Generic.PriorityQueue`2 +T:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection +T:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator +T:System.Collections.Generic.Queue`1 +T:System.Collections.Generic.Queue`1.Enumerator +T:System.Collections.Generic.ReferenceEqualityComparer +T:System.Collections.Generic.SortedDictionary`2 +T:System.Collections.Generic.SortedDictionary`2.Enumerator +T:System.Collections.Generic.SortedDictionary`2.KeyCollection +T:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator +T:System.Collections.Generic.SortedDictionary`2.ValueCollection +T:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator +T:System.Collections.Generic.SortedList`2 +T:System.Collections.Generic.SortedSet`1 +T:System.Collections.Generic.SortedSet`1.Enumerator +T:System.Collections.Generic.Stack`1 +T:System.Collections.Generic.Stack`1.Enumerator +T:System.Collections.StructuralComparisons \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt new file mode 100644 index 0000000000000..a9dec4ae8affc --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt @@ -0,0 +1,231 @@ +M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0}) +M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1}) +M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2}) +M:System.Linq.Enumerable.All``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.AsEnumerable``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Decimal}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Double}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Int32}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Int64}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Single}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +M:System.Linq.Enumerable.Cast``1(System.Collections.IEnumerable) +M:System.Linq.Enumerable.Chunk``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.Distinct``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Distinct``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.ElementAt``1(System.Collections.Generic.IEnumerable{``0},System.Index) +M:System.Linq.Enumerable.ElementAt``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.ElementAtOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Index) +M:System.Linq.Enumerable.ElementAtOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.Empty``1 +M:System.Linq.Enumerable.Except``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Except``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) +M:System.Linq.Enumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.First``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.First``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) +M:System.Linq.Enumerable.GroupBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.GroupBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2}) +M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3}) +M:System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3}) +M:System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2}) +M:System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) +M:System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3}) +M:System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2}) +M:System.Linq.Enumerable.Last``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Last``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) +M:System.Linq.Enumerable.LongCount``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.LongCount``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Decimal}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Double}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Int32}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Int64}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Single}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +M:System.Linq.Enumerable.Max``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Decimal}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Double}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Int32}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Int64}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Single}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +M:System.Linq.Enumerable.Min``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +M:System.Linq.Enumerable.OfType``1(System.Collections.IEnumerable) +M:System.Linq.Enumerable.Order``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Order``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +M:System.Linq.Enumerable.OrderByDescending``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.OrderByDescending``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +M:System.Linq.Enumerable.OrderDescending``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.OrderDescending``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) +M:System.Linq.Enumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.Range(System.Int32,System.Int32) +M:System.Linq.Enumerable.Repeat``1(``0,System.Int32) +M:System.Linq.Enumerable.Reverse``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Select``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.Select``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,``1}) +M:System.Linq.Enumerable.SelectMany``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}}) +M:System.Linq.Enumerable.SelectMany``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Collections.Generic.IEnumerable{``1}}) +M:System.Linq.Enumerable.SelectMany``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) +M:System.Linq.Enumerable.SelectMany``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) +M:System.Linq.Enumerable.SequenceEqual``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.SequenceEqual``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) +M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) +M:System.Linq.Enumerable.Skip``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.SkipWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.SkipWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Decimal}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Double}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Int32}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Int64}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Single}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) +M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) +M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Range) +M:System.Linq.Enumerable.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) +M:System.Linq.Enumerable.TakeWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.TakeWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) +M:System.Linq.Enumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +M:System.Linq.Enumerable.ThenByDescending``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.ThenByDescending``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) +M:System.Linq.Enumerable.ToArray``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) +M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}}) +M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.ToDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +M:System.Linq.Enumerable.ToDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.ToList``1(System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.ToLookup``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.ToLookup``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.ToLookup``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) +M:System.Linq.Enumerable.ToLookup``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.TryGetNonEnumeratedCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32@) +M:System.Linq.Enumerable.Union``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) +M:System.Linq.Enumerable.Union``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) +M:System.Linq.Enumerable.UnionBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) +M:System.Linq.Enumerable.UnionBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) +M:System.Linq.Enumerable.Where``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) +M:System.Linq.Enumerable.Where``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) +M:System.Linq.Enumerable.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1}) +M:System.Linq.Enumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2}) +M:System.Linq.Enumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2}) +M:System.Linq.IGrouping`2.get_Key +M:System.Linq.ILookup`2.Contains(`0) +M:System.Linq.ILookup`2.get_Count +M:System.Linq.ILookup`2.get_Item(`0) +M:System.Linq.IOrderedEnumerable`1.CreateOrderedEnumerable``1(System.Func{`0,``0},System.Collections.Generic.IComparer{``0},System.Boolean) +M:System.Linq.Lookup`2.ApplyResultSelector``1(System.Func{`0,System.Collections.Generic.IEnumerable{`1},``0}) +M:System.Linq.Lookup`2.Contains(`0) +M:System.Linq.Lookup`2.get_Count +M:System.Linq.Lookup`2.get_Item(`0) +M:System.Linq.Lookup`2.GetEnumerator +T:System.Linq.Enumerable +T:System.Linq.IGrouping`2 +T:System.Linq.ILookup`2 +T:System.Linq.IOrderedEnumerable`1 +T:System.Linq.Lookup`2 \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt new file mode 100644 index 0000000000000..9c3c4baadbf5d --- /dev/null +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt @@ -0,0 +1,7717 @@ +F:System.AttributeTargets.All +F:System.AttributeTargets.Assembly +F:System.AttributeTargets.Class +F:System.AttributeTargets.Constructor +F:System.AttributeTargets.Delegate +F:System.AttributeTargets.Enum +F:System.AttributeTargets.Event +F:System.AttributeTargets.Field +F:System.AttributeTargets.GenericParameter +F:System.AttributeTargets.Interface +F:System.AttributeTargets.Method +F:System.AttributeTargets.Module +F:System.AttributeTargets.Parameter +F:System.AttributeTargets.Property +F:System.AttributeTargets.ReturnValue +F:System.AttributeTargets.Struct +F:System.Base64FormattingOptions.InsertLineBreaks +F:System.Base64FormattingOptions.None +F:System.BitConverter.IsLittleEndian +F:System.Boolean.FalseString +F:System.Boolean.TrueString +F:System.Buffers.OperationStatus.DestinationTooSmall +F:System.Buffers.OperationStatus.Done +F:System.Buffers.OperationStatus.InvalidData +F:System.Buffers.OperationStatus.NeedMoreData +F:System.Byte.MaxValue +F:System.Byte.MinValue +F:System.Char.MaxValue +F:System.Char.MinValue +F:System.CodeDom.Compiler.IndentedTextWriter.DefaultTabString +F:System.Collections.Comparer.Default +F:System.Collections.Comparer.DefaultInvariant +F:System.ComponentModel.EditorBrowsableState.Advanced +F:System.ComponentModel.EditorBrowsableState.Always +F:System.ComponentModel.EditorBrowsableState.Never +F:System.Configuration.Assemblies.AssemblyHashAlgorithm.MD5 +F:System.Configuration.Assemblies.AssemblyHashAlgorithm.None +F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA1 +F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA256 +F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA384 +F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA512 +F:System.Configuration.Assemblies.AssemblyVersionCompatibility.SameDomain +F:System.Configuration.Assemblies.AssemblyVersionCompatibility.SameMachine +F:System.Configuration.Assemblies.AssemblyVersionCompatibility.SameProcess +F:System.Convert.DBNull +F:System.DateTime.MaxValue +F:System.DateTime.MinValue +F:System.DateTime.UnixEpoch +F:System.DateTimeKind.Local +F:System.DateTimeKind.Unspecified +F:System.DateTimeKind.Utc +F:System.DateTimeOffset.MaxValue +F:System.DateTimeOffset.MinValue +F:System.DateTimeOffset.UnixEpoch +F:System.DayOfWeek.Friday +F:System.DayOfWeek.Monday +F:System.DayOfWeek.Saturday +F:System.DayOfWeek.Sunday +F:System.DayOfWeek.Thursday +F:System.DayOfWeek.Tuesday +F:System.DayOfWeek.Wednesday +F:System.DBNull.Value +F:System.Decimal.MaxValue +F:System.Decimal.MinusOne +F:System.Decimal.MinValue +F:System.Decimal.One +F:System.Decimal.Zero +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.None +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor +F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.CompositeFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.DateOnlyFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.DateTimeFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.EnumFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.GuidFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Json +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.NumericFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.TimeOnlyFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.TimeSpanFormat +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Uri +F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Xml +F:System.Diagnostics.DebuggableAttribute.DebuggingModes.Default +F:System.Diagnostics.DebuggableAttribute.DebuggingModes.DisableOptimizations +F:System.Diagnostics.DebuggableAttribute.DebuggingModes.EnableEditAndContinue +F:System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints +F:System.Diagnostics.DebuggableAttribute.DebuggingModes.None +F:System.Diagnostics.DebuggerBrowsableState.Collapsed +F:System.Diagnostics.DebuggerBrowsableState.Never +F:System.Diagnostics.DebuggerBrowsableState.RootHidden +F:System.Diagnostics.Stopwatch.Frequency +F:System.Diagnostics.Stopwatch.IsHighResolution +F:System.Double.E +F:System.Double.Epsilon +F:System.Double.MaxValue +F:System.Double.MinValue +F:System.Double.NaN +F:System.Double.NegativeInfinity +F:System.Double.NegativeZero +F:System.Double.Pi +F:System.Double.PositiveInfinity +F:System.Double.Tau +F:System.EventArgs.Empty +F:System.GenericUriParserOptions.AllowEmptyAuthority +F:System.GenericUriParserOptions.Default +F:System.GenericUriParserOptions.DontCompressPath +F:System.GenericUriParserOptions.DontConvertPathBackslashes +F:System.GenericUriParserOptions.DontUnescapePathDotsAndSlashes +F:System.GenericUriParserOptions.GenericAuthority +F:System.GenericUriParserOptions.Idn +F:System.GenericUriParserOptions.IriParsing +F:System.GenericUriParserOptions.NoFragment +F:System.GenericUriParserOptions.NoPort +F:System.GenericUriParserOptions.NoQuery +F:System.GenericUriParserOptions.NoUserInfo +F:System.Globalization.Calendar.CurrentEra +F:System.Globalization.CalendarAlgorithmType.LunarCalendar +F:System.Globalization.CalendarAlgorithmType.LunisolarCalendar +F:System.Globalization.CalendarAlgorithmType.SolarCalendar +F:System.Globalization.CalendarAlgorithmType.Unknown +F:System.Globalization.CalendarWeekRule.FirstDay +F:System.Globalization.CalendarWeekRule.FirstFourDayWeek +F:System.Globalization.CalendarWeekRule.FirstFullWeek +F:System.Globalization.ChineseLunisolarCalendar.ChineseEra +F:System.Globalization.CompareOptions.IgnoreCase +F:System.Globalization.CompareOptions.IgnoreKanaType +F:System.Globalization.CompareOptions.IgnoreNonSpace +F:System.Globalization.CompareOptions.IgnoreSymbols +F:System.Globalization.CompareOptions.IgnoreWidth +F:System.Globalization.CompareOptions.None +F:System.Globalization.CompareOptions.Ordinal +F:System.Globalization.CompareOptions.OrdinalIgnoreCase +F:System.Globalization.CompareOptions.StringSort +F:System.Globalization.CultureTypes.AllCultures +F:System.Globalization.CultureTypes.FrameworkCultures +F:System.Globalization.CultureTypes.InstalledWin32Cultures +F:System.Globalization.CultureTypes.NeutralCultures +F:System.Globalization.CultureTypes.ReplacementCultures +F:System.Globalization.CultureTypes.SpecificCultures +F:System.Globalization.CultureTypes.UserCustomCulture +F:System.Globalization.CultureTypes.WindowsOnlyCultures +F:System.Globalization.DateTimeStyles.AdjustToUniversal +F:System.Globalization.DateTimeStyles.AllowInnerWhite +F:System.Globalization.DateTimeStyles.AllowLeadingWhite +F:System.Globalization.DateTimeStyles.AllowTrailingWhite +F:System.Globalization.DateTimeStyles.AllowWhiteSpaces +F:System.Globalization.DateTimeStyles.AssumeLocal +F:System.Globalization.DateTimeStyles.AssumeUniversal +F:System.Globalization.DateTimeStyles.NoCurrentDateDefault +F:System.Globalization.DateTimeStyles.None +F:System.Globalization.DateTimeStyles.RoundtripKind +F:System.Globalization.DigitShapes.Context +F:System.Globalization.DigitShapes.NativeNational +F:System.Globalization.DigitShapes.None +F:System.Globalization.GregorianCalendar.ADEra +F:System.Globalization.GregorianCalendarTypes.Arabic +F:System.Globalization.GregorianCalendarTypes.Localized +F:System.Globalization.GregorianCalendarTypes.MiddleEastFrench +F:System.Globalization.GregorianCalendarTypes.TransliteratedEnglish +F:System.Globalization.GregorianCalendarTypes.TransliteratedFrench +F:System.Globalization.GregorianCalendarTypes.USEnglish +F:System.Globalization.HebrewCalendar.HebrewEra +F:System.Globalization.HijriCalendar.HijriEra +F:System.Globalization.JapaneseLunisolarCalendar.JapaneseEra +F:System.Globalization.JulianCalendar.JulianEra +F:System.Globalization.KoreanCalendar.KoreanEra +F:System.Globalization.KoreanLunisolarCalendar.GregorianEra +F:System.Globalization.NumberStyles.AllowBinarySpecifier +F:System.Globalization.NumberStyles.AllowCurrencySymbol +F:System.Globalization.NumberStyles.AllowDecimalPoint +F:System.Globalization.NumberStyles.AllowExponent +F:System.Globalization.NumberStyles.AllowHexSpecifier +F:System.Globalization.NumberStyles.AllowLeadingSign +F:System.Globalization.NumberStyles.AllowLeadingWhite +F:System.Globalization.NumberStyles.AllowParentheses +F:System.Globalization.NumberStyles.AllowThousands +F:System.Globalization.NumberStyles.AllowTrailingSign +F:System.Globalization.NumberStyles.AllowTrailingWhite +F:System.Globalization.NumberStyles.Any +F:System.Globalization.NumberStyles.BinaryNumber +F:System.Globalization.NumberStyles.Currency +F:System.Globalization.NumberStyles.Float +F:System.Globalization.NumberStyles.HexNumber +F:System.Globalization.NumberStyles.Integer +F:System.Globalization.NumberStyles.None +F:System.Globalization.NumberStyles.Number +F:System.Globalization.PersianCalendar.PersianEra +F:System.Globalization.ThaiBuddhistCalendar.ThaiBuddhistEra +F:System.Globalization.TimeSpanStyles.AssumeNegative +F:System.Globalization.TimeSpanStyles.None +F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra +F:System.Globalization.UnicodeCategory.ClosePunctuation +F:System.Globalization.UnicodeCategory.ConnectorPunctuation +F:System.Globalization.UnicodeCategory.Control +F:System.Globalization.UnicodeCategory.CurrencySymbol +F:System.Globalization.UnicodeCategory.DashPunctuation +F:System.Globalization.UnicodeCategory.DecimalDigitNumber +F:System.Globalization.UnicodeCategory.EnclosingMark +F:System.Globalization.UnicodeCategory.FinalQuotePunctuation +F:System.Globalization.UnicodeCategory.Format +F:System.Globalization.UnicodeCategory.InitialQuotePunctuation +F:System.Globalization.UnicodeCategory.LetterNumber +F:System.Globalization.UnicodeCategory.LineSeparator +F:System.Globalization.UnicodeCategory.LowercaseLetter +F:System.Globalization.UnicodeCategory.MathSymbol +F:System.Globalization.UnicodeCategory.ModifierLetter +F:System.Globalization.UnicodeCategory.ModifierSymbol +F:System.Globalization.UnicodeCategory.NonSpacingMark +F:System.Globalization.UnicodeCategory.OpenPunctuation +F:System.Globalization.UnicodeCategory.OtherLetter +F:System.Globalization.UnicodeCategory.OtherNotAssigned +F:System.Globalization.UnicodeCategory.OtherNumber +F:System.Globalization.UnicodeCategory.OtherPunctuation +F:System.Globalization.UnicodeCategory.OtherSymbol +F:System.Globalization.UnicodeCategory.ParagraphSeparator +F:System.Globalization.UnicodeCategory.PrivateUse +F:System.Globalization.UnicodeCategory.SpaceSeparator +F:System.Globalization.UnicodeCategory.SpacingCombiningMark +F:System.Globalization.UnicodeCategory.Surrogate +F:System.Globalization.UnicodeCategory.TitlecaseLetter +F:System.Globalization.UnicodeCategory.UppercaseLetter +F:System.Guid.Empty +F:System.Int16.MaxValue +F:System.Int16.MinValue +F:System.Int32.MaxValue +F:System.Int32.MinValue +F:System.Int64.MaxValue +F:System.Int64.MinValue +F:System.IntPtr.Zero +F:System.Math.E +F:System.Math.PI +F:System.Math.Tau +F:System.MathF.E +F:System.MathF.PI +F:System.MathF.Tau +F:System.MidpointRounding.AwayFromZero +F:System.MidpointRounding.ToEven +F:System.MidpointRounding.ToNegativeInfinity +F:System.MidpointRounding.ToPositiveInfinity +F:System.MidpointRounding.ToZero +F:System.MissingMemberException.ClassName +F:System.MissingMemberException.MemberName +F:System.MissingMemberException.Signature +F:System.ModuleHandle.EmptyHandle +F:System.PlatformID.MacOSX +F:System.PlatformID.Other +F:System.PlatformID.Unix +F:System.PlatformID.Win32NT +F:System.PlatformID.Win32S +F:System.PlatformID.Win32Windows +F:System.PlatformID.WinCE +F:System.PlatformID.Xbox +F:System.Runtime.CompilerServices.CompilationRelaxations.NoStringInterning +F:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.RefStructs +F:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.RequiredMembers +F:System.Runtime.CompilerServices.LoadHint.Always +F:System.Runtime.CompilerServices.LoadHint.Default +F:System.Runtime.CompilerServices.LoadHint.Sometimes +F:System.Runtime.CompilerServices.MethodCodeType.IL +F:System.Runtime.CompilerServices.MethodCodeType.Native +F:System.Runtime.CompilerServices.MethodCodeType.OPTIL +F:System.Runtime.CompilerServices.MethodCodeType.Runtime +F:System.Runtime.CompilerServices.MethodImplAttribute.MethodCodeType +F:System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining +F:System.Runtime.CompilerServices.MethodImplOptions.AggressiveOptimization +F:System.Runtime.CompilerServices.MethodImplOptions.ForwardRef +F:System.Runtime.CompilerServices.MethodImplOptions.InternalCall +F:System.Runtime.CompilerServices.MethodImplOptions.NoInlining +F:System.Runtime.CompilerServices.MethodImplOptions.NoOptimization +F:System.Runtime.CompilerServices.MethodImplOptions.PreserveSig +F:System.Runtime.CompilerServices.MethodImplOptions.Synchronized +F:System.Runtime.CompilerServices.MethodImplOptions.Unmanaged +F:System.Runtime.CompilerServices.NullableAttribute.NullableFlags +F:System.Runtime.CompilerServices.NullableContextAttribute.Flag +F:System.Runtime.CompilerServices.NullablePublicOnlyAttribute.IncludesInternals +F:System.Runtime.CompilerServices.RuntimeFeature.ByRefFields +F:System.Runtime.CompilerServices.RuntimeFeature.CovariantReturnsOfClasses +F:System.Runtime.CompilerServices.RuntimeFeature.DefaultImplementationsOfInterfaces +F:System.Runtime.CompilerServices.RuntimeFeature.NumericIntPtr +F:System.Runtime.CompilerServices.RuntimeFeature.PortablePdb +F:System.Runtime.CompilerServices.RuntimeFeature.UnmanagedSignatureCallingConvention +F:System.Runtime.CompilerServices.RuntimeFeature.VirtualStaticsInInterfaces +F:System.Runtime.CompilerServices.StrongBox`1.Value +F:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor +F:System.Runtime.CompilerServices.UnsafeAccessorKind.Field +F:System.Runtime.CompilerServices.UnsafeAccessorKind.Method +F:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticField +F:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticMethod +F:System.SByte.MaxValue +F:System.SByte.MinValue +F:System.Single.E +F:System.Single.Epsilon +F:System.Single.MaxValue +F:System.Single.MinValue +F:System.Single.NaN +F:System.Single.NegativeInfinity +F:System.Single.NegativeZero +F:System.Single.Pi +F:System.Single.PositiveInfinity +F:System.Single.Tau +F:System.String.Empty +F:System.StringComparison.CurrentCulture +F:System.StringComparison.CurrentCultureIgnoreCase +F:System.StringComparison.InvariantCulture +F:System.StringComparison.InvariantCultureIgnoreCase +F:System.StringComparison.Ordinal +F:System.StringComparison.OrdinalIgnoreCase +F:System.StringSplitOptions.None +F:System.StringSplitOptions.RemoveEmptyEntries +F:System.StringSplitOptions.TrimEntries +F:System.Text.NormalizationForm.FormC +F:System.Text.NormalizationForm.FormD +F:System.Text.NormalizationForm.FormKC +F:System.Text.NormalizationForm.FormKD +F:System.Threading.Tasks.ConfigureAwaitOptions.ContinueOnCapturedContext +F:System.Threading.Tasks.ConfigureAwaitOptions.ForceYielding +F:System.Threading.Tasks.ConfigureAwaitOptions.None +F:System.Threading.Tasks.ConfigureAwaitOptions.SuppressThrowing +F:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.FlowExecutionContext +F:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.None +F:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.UseSchedulingContext +F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Canceled +F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Faulted +F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Pending +F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Succeeded +F:System.Threading.Tasks.TaskContinuationOptions.AttachedToParent +F:System.Threading.Tasks.TaskContinuationOptions.DenyChildAttach +F:System.Threading.Tasks.TaskContinuationOptions.ExecuteSynchronously +F:System.Threading.Tasks.TaskContinuationOptions.HideScheduler +F:System.Threading.Tasks.TaskContinuationOptions.LazyCancellation +F:System.Threading.Tasks.TaskContinuationOptions.LongRunning +F:System.Threading.Tasks.TaskContinuationOptions.None +F:System.Threading.Tasks.TaskContinuationOptions.NotOnCanceled +F:System.Threading.Tasks.TaskContinuationOptions.NotOnFaulted +F:System.Threading.Tasks.TaskContinuationOptions.NotOnRanToCompletion +F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnCanceled +F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnFaulted +F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnRanToCompletion +F:System.Threading.Tasks.TaskContinuationOptions.PreferFairness +F:System.Threading.Tasks.TaskContinuationOptions.RunContinuationsAsynchronously +F:System.Threading.Tasks.TaskCreationOptions.AttachedToParent +F:System.Threading.Tasks.TaskCreationOptions.DenyChildAttach +F:System.Threading.Tasks.TaskCreationOptions.HideScheduler +F:System.Threading.Tasks.TaskCreationOptions.LongRunning +F:System.Threading.Tasks.TaskCreationOptions.None +F:System.Threading.Tasks.TaskCreationOptions.PreferFairness +F:System.Threading.Tasks.TaskCreationOptions.RunContinuationsAsynchronously +F:System.Threading.Tasks.TaskStatus.Canceled +F:System.Threading.Tasks.TaskStatus.Created +F:System.Threading.Tasks.TaskStatus.Faulted +F:System.Threading.Tasks.TaskStatus.RanToCompletion +F:System.Threading.Tasks.TaskStatus.Running +F:System.Threading.Tasks.TaskStatus.WaitingForActivation +F:System.Threading.Tasks.TaskStatus.WaitingForChildrenToComplete +F:System.Threading.Tasks.TaskStatus.WaitingToRun +F:System.TimeSpan.MaxValue +F:System.TimeSpan.MinValue +F:System.TimeSpan.NanosecondsPerTick +F:System.TimeSpan.TicksPerDay +F:System.TimeSpan.TicksPerHour +F:System.TimeSpan.TicksPerMicrosecond +F:System.TimeSpan.TicksPerMillisecond +F:System.TimeSpan.TicksPerMinute +F:System.TimeSpan.TicksPerSecond +F:System.TimeSpan.Zero +F:System.Type.Delimiter +F:System.Type.EmptyTypes +F:System.Type.FilterAttribute +F:System.Type.FilterName +F:System.Type.FilterNameIgnoreCase +F:System.Type.Missing +F:System.TypeCode.Boolean +F:System.TypeCode.Byte +F:System.TypeCode.Char +F:System.TypeCode.DateTime +F:System.TypeCode.DBNull +F:System.TypeCode.Decimal +F:System.TypeCode.Double +F:System.TypeCode.Empty +F:System.TypeCode.Int16 +F:System.TypeCode.Int32 +F:System.TypeCode.Int64 +F:System.TypeCode.Object +F:System.TypeCode.SByte +F:System.TypeCode.Single +F:System.TypeCode.String +F:System.TypeCode.UInt16 +F:System.TypeCode.UInt32 +F:System.TypeCode.UInt64 +F:System.UInt16.MaxValue +F:System.UInt16.MinValue +F:System.UInt32.MaxValue +F:System.UInt32.MinValue +F:System.UInt64.MaxValue +F:System.UInt64.MinValue +F:System.UIntPtr.Zero +F:System.Uri.SchemeDelimiter +F:System.Uri.UriSchemeFile +F:System.Uri.UriSchemeFtp +F:System.Uri.UriSchemeFtps +F:System.Uri.UriSchemeGopher +F:System.Uri.UriSchemeHttp +F:System.Uri.UriSchemeHttps +F:System.Uri.UriSchemeMailto +F:System.Uri.UriSchemeNetPipe +F:System.Uri.UriSchemeNetTcp +F:System.Uri.UriSchemeNews +F:System.Uri.UriSchemeNntp +F:System.Uri.UriSchemeSftp +F:System.Uri.UriSchemeSsh +F:System.Uri.UriSchemeTelnet +F:System.Uri.UriSchemeWs +F:System.Uri.UriSchemeWss +F:System.UriComponents.AbsoluteUri +F:System.UriComponents.Fragment +F:System.UriComponents.Host +F:System.UriComponents.HostAndPort +F:System.UriComponents.HttpRequestUrl +F:System.UriComponents.KeepDelimiter +F:System.UriComponents.NormalizedHost +F:System.UriComponents.Path +F:System.UriComponents.PathAndQuery +F:System.UriComponents.Port +F:System.UriComponents.Query +F:System.UriComponents.Scheme +F:System.UriComponents.SchemeAndServer +F:System.UriComponents.SerializationInfoString +F:System.UriComponents.StrongAuthority +F:System.UriComponents.StrongPort +F:System.UriComponents.UserInfo +F:System.UriFormat.SafeUnescaped +F:System.UriFormat.Unescaped +F:System.UriFormat.UriEscaped +F:System.UriHostNameType.Basic +F:System.UriHostNameType.Dns +F:System.UriHostNameType.IPv4 +F:System.UriHostNameType.IPv6 +F:System.UriHostNameType.Unknown +F:System.UriKind.Absolute +F:System.UriKind.Relative +F:System.UriKind.RelativeOrAbsolute +F:System.UriPartial.Authority +F:System.UriPartial.Path +F:System.UriPartial.Query +F:System.UriPartial.Scheme +F:System.ValueTuple`1.Item1 +F:System.ValueTuple`2.Item1 +F:System.ValueTuple`2.Item2 +F:System.ValueTuple`3.Item1 +F:System.ValueTuple`3.Item2 +F:System.ValueTuple`3.Item3 +F:System.ValueTuple`4.Item1 +F:System.ValueTuple`4.Item2 +F:System.ValueTuple`4.Item3 +F:System.ValueTuple`4.Item4 +F:System.ValueTuple`5.Item1 +F:System.ValueTuple`5.Item2 +F:System.ValueTuple`5.Item3 +F:System.ValueTuple`5.Item4 +F:System.ValueTuple`5.Item5 +F:System.ValueTuple`6.Item1 +F:System.ValueTuple`6.Item2 +F:System.ValueTuple`6.Item3 +F:System.ValueTuple`6.Item4 +F:System.ValueTuple`6.Item5 +F:System.ValueTuple`6.Item6 +F:System.ValueTuple`7.Item1 +F:System.ValueTuple`7.Item2 +F:System.ValueTuple`7.Item3 +F:System.ValueTuple`7.Item4 +F:System.ValueTuple`7.Item5 +F:System.ValueTuple`7.Item6 +F:System.ValueTuple`7.Item7 +F:System.ValueTuple`8.Item1 +F:System.ValueTuple`8.Item2 +F:System.ValueTuple`8.Item3 +F:System.ValueTuple`8.Item4 +F:System.ValueTuple`8.Item5 +F:System.ValueTuple`8.Item6 +F:System.ValueTuple`8.Item7 +F:System.ValueTuple`8.Rest +M:System.AccessViolationException.#ctor +M:System.AccessViolationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.AccessViolationException.#ctor(System.String) +M:System.AccessViolationException.#ctor(System.String,System.Exception) +M:System.Action.#ctor(System.Object,System.IntPtr) +M:System.Action.BeginInvoke(System.AsyncCallback,System.Object) +M:System.Action.EndInvoke(System.IAsyncResult) +M:System.Action.Invoke +M:System.Action`1.#ctor(System.Object,System.IntPtr) +M:System.Action`1.BeginInvoke(`0,System.AsyncCallback,System.Object) +M:System.Action`1.EndInvoke(System.IAsyncResult) +M:System.Action`1.Invoke(`0) +M:System.Action`10.#ctor(System.Object,System.IntPtr) +M:System.Action`10.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,System.AsyncCallback,System.Object) +M:System.Action`10.EndInvoke(System.IAsyncResult) +M:System.Action`10.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9) +M:System.Action`11.#ctor(System.Object,System.IntPtr) +M:System.Action`11.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,System.AsyncCallback,System.Object) +M:System.Action`11.EndInvoke(System.IAsyncResult) +M:System.Action`11.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10) +M:System.Action`12.#ctor(System.Object,System.IntPtr) +M:System.Action`12.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,System.AsyncCallback,System.Object) +M:System.Action`12.EndInvoke(System.IAsyncResult) +M:System.Action`12.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11) +M:System.Action`13.#ctor(System.Object,System.IntPtr) +M:System.Action`13.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,System.AsyncCallback,System.Object) +M:System.Action`13.EndInvoke(System.IAsyncResult) +M:System.Action`13.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12) +M:System.Action`14.#ctor(System.Object,System.IntPtr) +M:System.Action`14.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,System.AsyncCallback,System.Object) +M:System.Action`14.EndInvoke(System.IAsyncResult) +M:System.Action`14.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13) +M:System.Action`15.#ctor(System.Object,System.IntPtr) +M:System.Action`15.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,System.AsyncCallback,System.Object) +M:System.Action`15.EndInvoke(System.IAsyncResult) +M:System.Action`15.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14) +M:System.Action`16.#ctor(System.Object,System.IntPtr) +M:System.Action`16.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15,System.AsyncCallback,System.Object) +M:System.Action`16.EndInvoke(System.IAsyncResult) +M:System.Action`16.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15) +M:System.Action`2.#ctor(System.Object,System.IntPtr) +M:System.Action`2.BeginInvoke(`0,`1,System.AsyncCallback,System.Object) +M:System.Action`2.EndInvoke(System.IAsyncResult) +M:System.Action`2.Invoke(`0,`1) +M:System.Action`3.#ctor(System.Object,System.IntPtr) +M:System.Action`3.BeginInvoke(`0,`1,`2,System.AsyncCallback,System.Object) +M:System.Action`3.EndInvoke(System.IAsyncResult) +M:System.Action`3.Invoke(`0,`1,`2) +M:System.Action`4.#ctor(System.Object,System.IntPtr) +M:System.Action`4.BeginInvoke(`0,`1,`2,`3,System.AsyncCallback,System.Object) +M:System.Action`4.EndInvoke(System.IAsyncResult) +M:System.Action`4.Invoke(`0,`1,`2,`3) +M:System.Action`5.#ctor(System.Object,System.IntPtr) +M:System.Action`5.BeginInvoke(`0,`1,`2,`3,`4,System.AsyncCallback,System.Object) +M:System.Action`5.EndInvoke(System.IAsyncResult) +M:System.Action`5.Invoke(`0,`1,`2,`3,`4) +M:System.Action`6.#ctor(System.Object,System.IntPtr) +M:System.Action`6.BeginInvoke(`0,`1,`2,`3,`4,`5,System.AsyncCallback,System.Object) +M:System.Action`6.EndInvoke(System.IAsyncResult) +M:System.Action`6.Invoke(`0,`1,`2,`3,`4,`5) +M:System.Action`7.#ctor(System.Object,System.IntPtr) +M:System.Action`7.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,System.AsyncCallback,System.Object) +M:System.Action`7.EndInvoke(System.IAsyncResult) +M:System.Action`7.Invoke(`0,`1,`2,`3,`4,`5,`6) +M:System.Action`8.#ctor(System.Object,System.IntPtr) +M:System.Action`8.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,System.AsyncCallback,System.Object) +M:System.Action`8.EndInvoke(System.IAsyncResult) +M:System.Action`8.Invoke(`0,`1,`2,`3,`4,`5,`6,`7) +M:System.Action`9.#ctor(System.Object,System.IntPtr) +M:System.Action`9.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,System.AsyncCallback,System.Object) +M:System.Action`9.EndInvoke(System.IAsyncResult) +M:System.Action`9.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8) +M:System.AggregateException.#ctor +M:System.AggregateException.#ctor(System.Collections.Generic.IEnumerable{System.Exception}) +M:System.AggregateException.#ctor(System.Exception[]) +M:System.AggregateException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.AggregateException.#ctor(System.String) +M:System.AggregateException.#ctor(System.String,System.Collections.Generic.IEnumerable{System.Exception}) +M:System.AggregateException.#ctor(System.String,System.Exception) +M:System.AggregateException.#ctor(System.String,System.Exception[]) +M:System.AggregateException.Flatten +M:System.AggregateException.get_InnerExceptions +M:System.AggregateException.get_Message +M:System.AggregateException.GetBaseException +M:System.AggregateException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.AggregateException.Handle(System.Func{System.Exception,System.Boolean}) +M:System.AggregateException.ToString +M:System.ApplicationException.#ctor +M:System.ApplicationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ApplicationException.#ctor(System.String) +M:System.ApplicationException.#ctor(System.String,System.Exception) +M:System.ApplicationId.#ctor(System.Byte[],System.String,System.Version,System.String,System.String) +M:System.ApplicationId.Copy +M:System.ApplicationId.Equals(System.Object) +M:System.ApplicationId.get_Culture +M:System.ApplicationId.get_Name +M:System.ApplicationId.get_ProcessorArchitecture +M:System.ApplicationId.get_PublicKeyToken +M:System.ApplicationId.get_Version +M:System.ApplicationId.GetHashCode +M:System.ApplicationId.ToString +M:System.ArgIterator.#ctor(System.RuntimeArgumentHandle) +M:System.ArgIterator.#ctor(System.RuntimeArgumentHandle,System.Void*) +M:System.ArgIterator.End +M:System.ArgIterator.Equals(System.Object) +M:System.ArgIterator.GetHashCode +M:System.ArgIterator.GetNextArg +M:System.ArgIterator.GetNextArg(System.RuntimeTypeHandle) +M:System.ArgIterator.GetNextArgType +M:System.ArgIterator.GetRemainingCount +M:System.ArgumentException.#ctor +M:System.ArgumentException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArgumentException.#ctor(System.String) +M:System.ArgumentException.#ctor(System.String,System.Exception) +M:System.ArgumentException.#ctor(System.String,System.String) +M:System.ArgumentException.#ctor(System.String,System.String,System.Exception) +M:System.ArgumentException.get_Message +M:System.ArgumentException.get_ParamName +M:System.ArgumentException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArgumentException.ThrowIfNullOrEmpty(System.String,System.String) +M:System.ArgumentException.ThrowIfNullOrWhiteSpace(System.String,System.String) +M:System.ArgumentNullException.#ctor +M:System.ArgumentNullException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArgumentNullException.#ctor(System.String) +M:System.ArgumentNullException.#ctor(System.String,System.Exception) +M:System.ArgumentNullException.#ctor(System.String,System.String) +M:System.ArgumentNullException.ThrowIfNull(System.Object,System.String) +M:System.ArgumentNullException.ThrowIfNull(System.Void*,System.String) +M:System.ArgumentOutOfRangeException.#ctor +M:System.ArgumentOutOfRangeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArgumentOutOfRangeException.#ctor(System.String) +M:System.ArgumentOutOfRangeException.#ctor(System.String,System.Exception) +M:System.ArgumentOutOfRangeException.#ctor(System.String,System.Object,System.String) +M:System.ArgumentOutOfRangeException.#ctor(System.String,System.String) +M:System.ArgumentOutOfRangeException.get_ActualValue +M:System.ArgumentOutOfRangeException.get_Message +M:System.ArgumentOutOfRangeException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArgumentOutOfRangeException.ThrowIfEqual``1(``0,``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfGreaterThan``1(``0,``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual``1(``0,``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfLessThan``1(``0,``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfLessThanOrEqual``1(``0,``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfNegative``1(``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfNegativeOrZero``1(``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfNotEqual``1(``0,``0,System.String) +M:System.ArgumentOutOfRangeException.ThrowIfZero``1(``0,System.String) +M:System.ArithmeticException.#ctor +M:System.ArithmeticException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArithmeticException.#ctor(System.String) +M:System.ArithmeticException.#ctor(System.String,System.Exception) +M:System.Array.AsReadOnly``1(``0[]) +M:System.Array.BinarySearch(System.Array,System.Int32,System.Int32,System.Object) +M:System.Array.BinarySearch(System.Array,System.Int32,System.Int32,System.Object,System.Collections.IComparer) +M:System.Array.BinarySearch(System.Array,System.Object) +M:System.Array.BinarySearch(System.Array,System.Object,System.Collections.IComparer) +M:System.Array.BinarySearch``1(``0[],``0) +M:System.Array.BinarySearch``1(``0[],``0,System.Collections.Generic.IComparer{``0}) +M:System.Array.BinarySearch``1(``0[],System.Int32,System.Int32,``0) +M:System.Array.BinarySearch``1(``0[],System.Int32,System.Int32,``0,System.Collections.Generic.IComparer{``0}) +M:System.Array.Clear(System.Array) +M:System.Array.Clear(System.Array,System.Int32,System.Int32) +M:System.Array.Clone +M:System.Array.ConstrainedCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) +M:System.Array.ConvertAll``2(``0[],System.Converter{``0,``1}) +M:System.Array.Copy(System.Array,System.Array,System.Int32) +M:System.Array.Copy(System.Array,System.Array,System.Int64) +M:System.Array.Copy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) +M:System.Array.Copy(System.Array,System.Int64,System.Array,System.Int64,System.Int64) +M:System.Array.CopyTo(System.Array,System.Int32) +M:System.Array.CopyTo(System.Array,System.Int64) +M:System.Array.CreateInstance(System.Type,System.Int32) +M:System.Array.CreateInstance(System.Type,System.Int32,System.Int32) +M:System.Array.CreateInstance(System.Type,System.Int32,System.Int32,System.Int32) +M:System.Array.CreateInstance(System.Type,System.Int32[]) +M:System.Array.CreateInstance(System.Type,System.Int32[],System.Int32[]) +M:System.Array.CreateInstance(System.Type,System.Int64[]) +M:System.Array.Empty``1 +M:System.Array.Exists``1(``0[],System.Predicate{``0}) +M:System.Array.Fill``1(``0[],``0) +M:System.Array.Fill``1(``0[],``0,System.Int32,System.Int32) +M:System.Array.Find``1(``0[],System.Predicate{``0}) +M:System.Array.FindAll``1(``0[],System.Predicate{``0}) +M:System.Array.FindIndex``1(``0[],System.Int32,System.Int32,System.Predicate{``0}) +M:System.Array.FindIndex``1(``0[],System.Int32,System.Predicate{``0}) +M:System.Array.FindIndex``1(``0[],System.Predicate{``0}) +M:System.Array.FindLast``1(``0[],System.Predicate{``0}) +M:System.Array.FindLastIndex``1(``0[],System.Int32,System.Int32,System.Predicate{``0}) +M:System.Array.FindLastIndex``1(``0[],System.Int32,System.Predicate{``0}) +M:System.Array.FindLastIndex``1(``0[],System.Predicate{``0}) +M:System.Array.ForEach``1(``0[],System.Action{``0}) +M:System.Array.get_IsFixedSize +M:System.Array.get_IsReadOnly +M:System.Array.get_IsSynchronized +M:System.Array.get_Length +M:System.Array.get_LongLength +M:System.Array.get_MaxLength +M:System.Array.get_Rank +M:System.Array.get_SyncRoot +M:System.Array.GetEnumerator +M:System.Array.GetLength(System.Int32) +M:System.Array.GetLongLength(System.Int32) +M:System.Array.GetLowerBound(System.Int32) +M:System.Array.GetUpperBound(System.Int32) +M:System.Array.GetValue(System.Int32) +M:System.Array.GetValue(System.Int32,System.Int32) +M:System.Array.GetValue(System.Int32,System.Int32,System.Int32) +M:System.Array.GetValue(System.Int32[]) +M:System.Array.GetValue(System.Int64) +M:System.Array.GetValue(System.Int64,System.Int64) +M:System.Array.GetValue(System.Int64,System.Int64,System.Int64) +M:System.Array.GetValue(System.Int64[]) +M:System.Array.IndexOf(System.Array,System.Object) +M:System.Array.IndexOf(System.Array,System.Object,System.Int32) +M:System.Array.IndexOf(System.Array,System.Object,System.Int32,System.Int32) +M:System.Array.IndexOf``1(``0[],``0) +M:System.Array.IndexOf``1(``0[],``0,System.Int32) +M:System.Array.IndexOf``1(``0[],``0,System.Int32,System.Int32) +M:System.Array.Initialize +M:System.Array.LastIndexOf(System.Array,System.Object) +M:System.Array.LastIndexOf(System.Array,System.Object,System.Int32) +M:System.Array.LastIndexOf(System.Array,System.Object,System.Int32,System.Int32) +M:System.Array.LastIndexOf``1(``0[],``0) +M:System.Array.LastIndexOf``1(``0[],``0,System.Int32) +M:System.Array.LastIndexOf``1(``0[],``0,System.Int32,System.Int32) +M:System.Array.Resize``1(``0[]@,System.Int32) +M:System.Array.Reverse(System.Array) +M:System.Array.Reverse(System.Array,System.Int32,System.Int32) +M:System.Array.Reverse``1(``0[]) +M:System.Array.Reverse``1(``0[],System.Int32,System.Int32) +M:System.Array.SetValue(System.Object,System.Int32) +M:System.Array.SetValue(System.Object,System.Int32,System.Int32) +M:System.Array.SetValue(System.Object,System.Int32,System.Int32,System.Int32) +M:System.Array.SetValue(System.Object,System.Int32[]) +M:System.Array.SetValue(System.Object,System.Int64) +M:System.Array.SetValue(System.Object,System.Int64,System.Int64) +M:System.Array.SetValue(System.Object,System.Int64,System.Int64,System.Int64) +M:System.Array.SetValue(System.Object,System.Int64[]) +M:System.Array.Sort(System.Array) +M:System.Array.Sort(System.Array,System.Array) +M:System.Array.Sort(System.Array,System.Array,System.Collections.IComparer) +M:System.Array.Sort(System.Array,System.Array,System.Int32,System.Int32) +M:System.Array.Sort(System.Array,System.Array,System.Int32,System.Int32,System.Collections.IComparer) +M:System.Array.Sort(System.Array,System.Collections.IComparer) +M:System.Array.Sort(System.Array,System.Int32,System.Int32) +M:System.Array.Sort(System.Array,System.Int32,System.Int32,System.Collections.IComparer) +M:System.Array.Sort``1(``0[]) +M:System.Array.Sort``1(``0[],System.Collections.Generic.IComparer{``0}) +M:System.Array.Sort``1(``0[],System.Comparison{``0}) +M:System.Array.Sort``1(``0[],System.Int32,System.Int32) +M:System.Array.Sort``1(``0[],System.Int32,System.Int32,System.Collections.Generic.IComparer{``0}) +M:System.Array.Sort``2(``0[],``1[]) +M:System.Array.Sort``2(``0[],``1[],System.Collections.Generic.IComparer{``0}) +M:System.Array.Sort``2(``0[],``1[],System.Int32,System.Int32) +M:System.Array.Sort``2(``0[],``1[],System.Int32,System.Int32,System.Collections.Generic.IComparer{``0}) +M:System.Array.TrueForAll``1(``0[],System.Predicate{``0}) +M:System.ArraySegment`1.#ctor(`0[]) +M:System.ArraySegment`1.#ctor(`0[],System.Int32,System.Int32) +M:System.ArraySegment`1.CopyTo(`0[]) +M:System.ArraySegment`1.CopyTo(`0[],System.Int32) +M:System.ArraySegment`1.CopyTo(System.ArraySegment{`0}) +M:System.ArraySegment`1.Enumerator.Dispose +M:System.ArraySegment`1.Enumerator.get_Current +M:System.ArraySegment`1.Enumerator.MoveNext +M:System.ArraySegment`1.Equals(System.ArraySegment{`0}) +M:System.ArraySegment`1.Equals(System.Object) +M:System.ArraySegment`1.get_Array +M:System.ArraySegment`1.get_Count +M:System.ArraySegment`1.get_Empty +M:System.ArraySegment`1.get_Item(System.Int32) +M:System.ArraySegment`1.get_Offset +M:System.ArraySegment`1.GetEnumerator +M:System.ArraySegment`1.GetHashCode +M:System.ArraySegment`1.op_Equality(System.ArraySegment{`0},System.ArraySegment{`0}) +M:System.ArraySegment`1.op_Implicit(`0[])~System.ArraySegment{`0} +M:System.ArraySegment`1.op_Inequality(System.ArraySegment{`0},System.ArraySegment{`0}) +M:System.ArraySegment`1.set_Item(System.Int32,`0) +M:System.ArraySegment`1.Slice(System.Int32) +M:System.ArraySegment`1.Slice(System.Int32,System.Int32) +M:System.ArraySegment`1.ToArray +M:System.ArrayTypeMismatchException.#ctor +M:System.ArrayTypeMismatchException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ArrayTypeMismatchException.#ctor(System.String) +M:System.ArrayTypeMismatchException.#ctor(System.String,System.Exception) +M:System.AsyncCallback.#ctor(System.Object,System.IntPtr) +M:System.AsyncCallback.BeginInvoke(System.IAsyncResult,System.AsyncCallback,System.Object) +M:System.AsyncCallback.EndInvoke(System.IAsyncResult) +M:System.AsyncCallback.Invoke(System.IAsyncResult) +M:System.Attribute.#ctor +M:System.Attribute.Equals(System.Object) +M:System.Attribute.get_TypeId +M:System.Attribute.GetCustomAttribute(System.Reflection.Assembly,System.Type) +M:System.Attribute.GetCustomAttribute(System.Reflection.Assembly,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,System.Type) +M:System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttribute(System.Reflection.Module,System.Type) +M:System.Attribute.GetCustomAttribute(System.Reflection.Module,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,System.Type) +M:System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly) +M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Type) +M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo) +M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Type) +M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.Module) +M:System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Type) +M:System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Type,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo) +M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Boolean) +M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Type) +M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Type,System.Boolean) +M:System.Attribute.GetHashCode +M:System.Attribute.IsDefaultAttribute +M:System.Attribute.IsDefined(System.Reflection.Assembly,System.Type) +M:System.Attribute.IsDefined(System.Reflection.Assembly,System.Type,System.Boolean) +M:System.Attribute.IsDefined(System.Reflection.MemberInfo,System.Type) +M:System.Attribute.IsDefined(System.Reflection.MemberInfo,System.Type,System.Boolean) +M:System.Attribute.IsDefined(System.Reflection.Module,System.Type) +M:System.Attribute.IsDefined(System.Reflection.Module,System.Type,System.Boolean) +M:System.Attribute.IsDefined(System.Reflection.ParameterInfo,System.Type) +M:System.Attribute.IsDefined(System.Reflection.ParameterInfo,System.Type,System.Boolean) +M:System.Attribute.Match(System.Object) +M:System.AttributeUsageAttribute.#ctor(System.AttributeTargets) +M:System.AttributeUsageAttribute.get_AllowMultiple +M:System.AttributeUsageAttribute.get_Inherited +M:System.AttributeUsageAttribute.get_ValidOn +M:System.AttributeUsageAttribute.set_AllowMultiple(System.Boolean) +M:System.AttributeUsageAttribute.set_Inherited(System.Boolean) +M:System.BadImageFormatException.#ctor +M:System.BadImageFormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.BadImageFormatException.#ctor(System.String) +M:System.BadImageFormatException.#ctor(System.String,System.Exception) +M:System.BadImageFormatException.#ctor(System.String,System.String) +M:System.BadImageFormatException.#ctor(System.String,System.String,System.Exception) +M:System.BadImageFormatException.get_FileName +M:System.BadImageFormatException.get_FusionLog +M:System.BadImageFormatException.get_Message +M:System.BadImageFormatException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.BadImageFormatException.ToString +M:System.BitConverter.DoubleToInt64Bits(System.Double) +M:System.BitConverter.DoubleToUInt64Bits(System.Double) +M:System.BitConverter.GetBytes(System.Boolean) +M:System.BitConverter.GetBytes(System.Char) +M:System.BitConverter.GetBytes(System.Double) +M:System.BitConverter.GetBytes(System.Half) +M:System.BitConverter.GetBytes(System.Int16) +M:System.BitConverter.GetBytes(System.Int32) +M:System.BitConverter.GetBytes(System.Int64) +M:System.BitConverter.GetBytes(System.Single) +M:System.BitConverter.GetBytes(System.UInt16) +M:System.BitConverter.GetBytes(System.UInt32) +M:System.BitConverter.GetBytes(System.UInt64) +M:System.BitConverter.HalfToInt16Bits(System.Half) +M:System.BitConverter.HalfToUInt16Bits(System.Half) +M:System.BitConverter.Int16BitsToHalf(System.Int16) +M:System.BitConverter.Int32BitsToSingle(System.Int32) +M:System.BitConverter.Int64BitsToDouble(System.Int64) +M:System.BitConverter.SingleToInt32Bits(System.Single) +M:System.BitConverter.SingleToUInt32Bits(System.Single) +M:System.BitConverter.ToBoolean(System.Byte[],System.Int32) +M:System.BitConverter.ToBoolean(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToChar(System.Byte[],System.Int32) +M:System.BitConverter.ToChar(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToDouble(System.Byte[],System.Int32) +M:System.BitConverter.ToDouble(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToHalf(System.Byte[],System.Int32) +M:System.BitConverter.ToHalf(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToInt16(System.Byte[],System.Int32) +M:System.BitConverter.ToInt16(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToInt32(System.Byte[],System.Int32) +M:System.BitConverter.ToInt32(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToInt64(System.Byte[],System.Int32) +M:System.BitConverter.ToInt64(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToSingle(System.Byte[],System.Int32) +M:System.BitConverter.ToSingle(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToString(System.Byte[]) +M:System.BitConverter.ToString(System.Byte[],System.Int32) +M:System.BitConverter.ToString(System.Byte[],System.Int32,System.Int32) +M:System.BitConverter.ToUInt16(System.Byte[],System.Int32) +M:System.BitConverter.ToUInt16(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToUInt32(System.Byte[],System.Int32) +M:System.BitConverter.ToUInt32(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.ToUInt64(System.Byte[],System.Int32) +M:System.BitConverter.ToUInt64(System.ReadOnlySpan{System.Byte}) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Boolean) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Char) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Double) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Half) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int16) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int32) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int64) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Single) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt16) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt32) +M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt64) +M:System.BitConverter.UInt16BitsToHalf(System.UInt16) +M:System.BitConverter.UInt32BitsToSingle(System.UInt32) +M:System.BitConverter.UInt64BitsToDouble(System.UInt64) +M:System.Boolean.CompareTo(System.Boolean) +M:System.Boolean.CompareTo(System.Object) +M:System.Boolean.Equals(System.Boolean) +M:System.Boolean.Equals(System.Object) +M:System.Boolean.GetHashCode +M:System.Boolean.GetTypeCode +M:System.Boolean.Parse(System.ReadOnlySpan{System.Char}) +M:System.Boolean.Parse(System.String) +M:System.Boolean.ToString +M:System.Boolean.ToString(System.IFormatProvider) +M:System.Boolean.TryFormat(System.Span{System.Char},System.Int32@) +M:System.Boolean.TryParse(System.ReadOnlySpan{System.Char},System.Boolean@) +M:System.Boolean.TryParse(System.String,System.Boolean@) +M:System.Buffer.BlockCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) +M:System.Buffer.ByteLength(System.Array) +M:System.Buffer.GetByte(System.Array,System.Int32) +M:System.Buffer.MemoryCopy(System.Void*,System.Void*,System.Int64,System.Int64) +M:System.Buffer.MemoryCopy(System.Void*,System.Void*,System.UInt64,System.UInt64) +M:System.Buffer.SetByte(System.Array,System.Int32,System.Byte) +M:System.Buffers.ArrayPool`1.#ctor +M:System.Buffers.ArrayPool`1.Create +M:System.Buffers.ArrayPool`1.Create(System.Int32,System.Int32) +M:System.Buffers.ArrayPool`1.get_Shared +M:System.Buffers.ArrayPool`1.Rent(System.Int32) +M:System.Buffers.ArrayPool`1.Return(`0[],System.Boolean) +M:System.Buffers.IMemoryOwner`1.get_Memory +M:System.Buffers.IPinnable.Pin(System.Int32) +M:System.Buffers.IPinnable.Unpin +M:System.Buffers.MemoryHandle.#ctor(System.Void*,System.Runtime.InteropServices.GCHandle,System.Buffers.IPinnable) +M:System.Buffers.MemoryHandle.Dispose +M:System.Buffers.MemoryHandle.get_Pointer +M:System.Buffers.MemoryManager`1.#ctor +M:System.Buffers.MemoryManager`1.CreateMemory(System.Int32) +M:System.Buffers.MemoryManager`1.CreateMemory(System.Int32,System.Int32) +M:System.Buffers.MemoryManager`1.Dispose(System.Boolean) +M:System.Buffers.MemoryManager`1.get_Memory +M:System.Buffers.MemoryManager`1.GetSpan +M:System.Buffers.MemoryManager`1.Pin(System.Int32) +M:System.Buffers.MemoryManager`1.TryGetArray(System.ArraySegment{`0}@) +M:System.Buffers.MemoryManager`1.Unpin +M:System.Buffers.ReadOnlySpanAction`2.#ctor(System.Object,System.IntPtr) +M:System.Buffers.ReadOnlySpanAction`2.BeginInvoke(System.ReadOnlySpan{`0},`1,System.AsyncCallback,System.Object) +M:System.Buffers.ReadOnlySpanAction`2.EndInvoke(System.IAsyncResult) +M:System.Buffers.ReadOnlySpanAction`2.Invoke(System.ReadOnlySpan{`0},`1) +M:System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Byte}) +M:System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Char}) +M:System.Buffers.SearchValues`1.Contains(`0) +M:System.Buffers.SpanAction`2.#ctor(System.Object,System.IntPtr) +M:System.Buffers.SpanAction`2.BeginInvoke(System.Span{`0},`1,System.AsyncCallback,System.Object) +M:System.Buffers.SpanAction`2.EndInvoke(System.IAsyncResult) +M:System.Buffers.SpanAction`2.Invoke(System.Span{`0},`1) +M:System.Buffers.Text.Base64.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +M:System.Buffers.Text.Base64.DecodeFromUtf8InPlace(System.Span{System.Byte},System.Int32@) +M:System.Buffers.Text.Base64.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) +M:System.Buffers.Text.Base64.EncodeToUtf8InPlace(System.Span{System.Byte},System.Int32,System.Int32@) +M:System.Buffers.Text.Base64.GetMaxDecodedFromUtf8Length(System.Int32) +M:System.Buffers.Text.Base64.GetMaxEncodedToUtf8Length(System.Int32) +M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte}) +M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte},System.Int32@) +M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char}) +M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char},System.Int32@) +M:System.Byte.Clamp(System.Byte,System.Byte,System.Byte) +M:System.Byte.CompareTo(System.Byte) +M:System.Byte.CompareTo(System.Object) +M:System.Byte.CreateChecked``1(``0) +M:System.Byte.CreateSaturating``1(``0) +M:System.Byte.CreateTruncating``1(``0) +M:System.Byte.DivRem(System.Byte,System.Byte) +M:System.Byte.Equals(System.Byte) +M:System.Byte.Equals(System.Object) +M:System.Byte.GetHashCode +M:System.Byte.GetTypeCode +M:System.Byte.IsEvenInteger(System.Byte) +M:System.Byte.IsOddInteger(System.Byte) +M:System.Byte.IsPow2(System.Byte) +M:System.Byte.LeadingZeroCount(System.Byte) +M:System.Byte.Log2(System.Byte) +M:System.Byte.Max(System.Byte,System.Byte) +M:System.Byte.Min(System.Byte,System.Byte) +M:System.Byte.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Byte.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Byte.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Byte.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Byte.Parse(System.String) +M:System.Byte.Parse(System.String,System.Globalization.NumberStyles) +M:System.Byte.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Byte.Parse(System.String,System.IFormatProvider) +M:System.Byte.PopCount(System.Byte) +M:System.Byte.RotateLeft(System.Byte,System.Int32) +M:System.Byte.RotateRight(System.Byte,System.Int32) +M:System.Byte.Sign(System.Byte) +M:System.Byte.ToString +M:System.Byte.ToString(System.IFormatProvider) +M:System.Byte.ToString(System.String) +M:System.Byte.ToString(System.String,System.IFormatProvider) +M:System.Byte.TrailingZeroCount(System.Byte) +M:System.Byte.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Byte.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.Byte@) +M:System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) +M:System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Byte@) +M:System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.Byte@) +M:System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) +M:System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Byte@) +M:System.Byte.TryParse(System.String,System.Byte@) +M:System.Byte.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) +M:System.Byte.TryParse(System.String,System.IFormatProvider,System.Byte@) +M:System.CannotUnloadAppDomainException.#ctor +M:System.CannotUnloadAppDomainException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.CannotUnloadAppDomainException.#ctor(System.String) +M:System.CannotUnloadAppDomainException.#ctor(System.String,System.Exception) +M:System.Char.CompareTo(System.Char) +M:System.Char.CompareTo(System.Object) +M:System.Char.ConvertFromUtf32(System.Int32) +M:System.Char.ConvertToUtf32(System.Char,System.Char) +M:System.Char.ConvertToUtf32(System.String,System.Int32) +M:System.Char.Equals(System.Char) +M:System.Char.Equals(System.Object) +M:System.Char.GetHashCode +M:System.Char.GetNumericValue(System.Char) +M:System.Char.GetNumericValue(System.String,System.Int32) +M:System.Char.GetTypeCode +M:System.Char.GetUnicodeCategory(System.Char) +M:System.Char.GetUnicodeCategory(System.String,System.Int32) +M:System.Char.IsAscii(System.Char) +M:System.Char.IsAsciiDigit(System.Char) +M:System.Char.IsAsciiHexDigit(System.Char) +M:System.Char.IsAsciiHexDigitLower(System.Char) +M:System.Char.IsAsciiHexDigitUpper(System.Char) +M:System.Char.IsAsciiLetter(System.Char) +M:System.Char.IsAsciiLetterLower(System.Char) +M:System.Char.IsAsciiLetterOrDigit(System.Char) +M:System.Char.IsAsciiLetterUpper(System.Char) +M:System.Char.IsBetween(System.Char,System.Char,System.Char) +M:System.Char.IsControl(System.Char) +M:System.Char.IsControl(System.String,System.Int32) +M:System.Char.IsDigit(System.Char) +M:System.Char.IsDigit(System.String,System.Int32) +M:System.Char.IsHighSurrogate(System.Char) +M:System.Char.IsHighSurrogate(System.String,System.Int32) +M:System.Char.IsLetter(System.Char) +M:System.Char.IsLetter(System.String,System.Int32) +M:System.Char.IsLetterOrDigit(System.Char) +M:System.Char.IsLetterOrDigit(System.String,System.Int32) +M:System.Char.IsLower(System.Char) +M:System.Char.IsLower(System.String,System.Int32) +M:System.Char.IsLowSurrogate(System.Char) +M:System.Char.IsLowSurrogate(System.String,System.Int32) +M:System.Char.IsNumber(System.Char) +M:System.Char.IsNumber(System.String,System.Int32) +M:System.Char.IsPunctuation(System.Char) +M:System.Char.IsPunctuation(System.String,System.Int32) +M:System.Char.IsSeparator(System.Char) +M:System.Char.IsSeparator(System.String,System.Int32) +M:System.Char.IsSurrogate(System.Char) +M:System.Char.IsSurrogate(System.String,System.Int32) +M:System.Char.IsSurrogatePair(System.Char,System.Char) +M:System.Char.IsSurrogatePair(System.String,System.Int32) +M:System.Char.IsSymbol(System.Char) +M:System.Char.IsSymbol(System.String,System.Int32) +M:System.Char.IsUpper(System.Char) +M:System.Char.IsUpper(System.String,System.Int32) +M:System.Char.IsWhiteSpace(System.Char) +M:System.Char.IsWhiteSpace(System.String,System.Int32) +M:System.Char.Parse(System.String) +M:System.Char.ToLower(System.Char) +M:System.Char.ToLower(System.Char,System.Globalization.CultureInfo) +M:System.Char.ToLowerInvariant(System.Char) +M:System.Char.ToString +M:System.Char.ToString(System.Char) +M:System.Char.ToString(System.IFormatProvider) +M:System.Char.ToUpper(System.Char) +M:System.Char.ToUpper(System.Char,System.Globalization.CultureInfo) +M:System.Char.ToUpperInvariant(System.Char) +M:System.Char.TryParse(System.String,System.Char@) +M:System.CharEnumerator.Clone +M:System.CharEnumerator.Dispose +M:System.CharEnumerator.get_Current +M:System.CharEnumerator.MoveNext +M:System.CharEnumerator.Reset +M:System.CLSCompliantAttribute.#ctor(System.Boolean) +M:System.CLSCompliantAttribute.get_IsCompliant +M:System.CodeDom.Compiler.GeneratedCodeAttribute.#ctor(System.String,System.String) +M:System.CodeDom.Compiler.GeneratedCodeAttribute.get_Tool +M:System.CodeDom.Compiler.GeneratedCodeAttribute.get_Version +M:System.CodeDom.Compiler.IndentedTextWriter.#ctor(System.IO.TextWriter) +M:System.CodeDom.Compiler.IndentedTextWriter.#ctor(System.IO.TextWriter,System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.Close +M:System.CodeDom.Compiler.IndentedTextWriter.DisposeAsync +M:System.CodeDom.Compiler.IndentedTextWriter.Flush +M:System.CodeDom.Compiler.IndentedTextWriter.FlushAsync +M:System.CodeDom.Compiler.IndentedTextWriter.FlushAsync(System.Threading.CancellationToken) +M:System.CodeDom.Compiler.IndentedTextWriter.get_Encoding +M:System.CodeDom.Compiler.IndentedTextWriter.get_Indent +M:System.CodeDom.Compiler.IndentedTextWriter.get_InnerWriter +M:System.CodeDom.Compiler.IndentedTextWriter.get_NewLine +M:System.CodeDom.Compiler.IndentedTextWriter.OutputTabs +M:System.CodeDom.Compiler.IndentedTextWriter.OutputTabsAsync +M:System.CodeDom.Compiler.IndentedTextWriter.set_Indent(System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.set_NewLine(System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Boolean) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Char) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Char[]) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Char[],System.Int32,System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Double) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Int64) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Object) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Single) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String,System.Object) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String,System.Object,System.Object) +M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String,System.Object[]) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.Char) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.Char[],System.Int32,System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.ReadOnlyMemory{System.Char},System.Threading.CancellationToken) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.Text.StringBuilder,System.Threading.CancellationToken) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Boolean) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Char) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Char[]) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Char[],System.Int32,System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Double) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Int64) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Object) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Single) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String,System.Object) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String,System.Object,System.Object) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String,System.Object[]) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.UInt32) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.Char) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.Char[],System.Int32,System.Int32) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.ReadOnlyMemory{System.Char},System.Threading.CancellationToken) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.Text.StringBuilder,System.Threading.CancellationToken) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineNoTabs(System.String) +M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineNoTabsAsync(System.String) +M:System.Collections.ArrayList.#ctor +M:System.Collections.ArrayList.#ctor(System.Collections.ICollection) +M:System.Collections.ArrayList.#ctor(System.Int32) +M:System.Collections.ArrayList.Adapter(System.Collections.IList) +M:System.Collections.ArrayList.Add(System.Object) +M:System.Collections.ArrayList.AddRange(System.Collections.ICollection) +M:System.Collections.ArrayList.BinarySearch(System.Int32,System.Int32,System.Object,System.Collections.IComparer) +M:System.Collections.ArrayList.BinarySearch(System.Object) +M:System.Collections.ArrayList.BinarySearch(System.Object,System.Collections.IComparer) +M:System.Collections.ArrayList.Clear +M:System.Collections.ArrayList.Clone +M:System.Collections.ArrayList.Contains(System.Object) +M:System.Collections.ArrayList.CopyTo(System.Array) +M:System.Collections.ArrayList.CopyTo(System.Array,System.Int32) +M:System.Collections.ArrayList.CopyTo(System.Int32,System.Array,System.Int32,System.Int32) +M:System.Collections.ArrayList.FixedSize(System.Collections.ArrayList) +M:System.Collections.ArrayList.FixedSize(System.Collections.IList) +M:System.Collections.ArrayList.get_Capacity +M:System.Collections.ArrayList.get_Count +M:System.Collections.ArrayList.get_IsFixedSize +M:System.Collections.ArrayList.get_IsReadOnly +M:System.Collections.ArrayList.get_IsSynchronized +M:System.Collections.ArrayList.get_Item(System.Int32) +M:System.Collections.ArrayList.get_SyncRoot +M:System.Collections.ArrayList.GetEnumerator +M:System.Collections.ArrayList.GetEnumerator(System.Int32,System.Int32) +M:System.Collections.ArrayList.GetRange(System.Int32,System.Int32) +M:System.Collections.ArrayList.IndexOf(System.Object) +M:System.Collections.ArrayList.IndexOf(System.Object,System.Int32) +M:System.Collections.ArrayList.IndexOf(System.Object,System.Int32,System.Int32) +M:System.Collections.ArrayList.Insert(System.Int32,System.Object) +M:System.Collections.ArrayList.InsertRange(System.Int32,System.Collections.ICollection) +M:System.Collections.ArrayList.LastIndexOf(System.Object) +M:System.Collections.ArrayList.LastIndexOf(System.Object,System.Int32) +M:System.Collections.ArrayList.LastIndexOf(System.Object,System.Int32,System.Int32) +M:System.Collections.ArrayList.ReadOnly(System.Collections.ArrayList) +M:System.Collections.ArrayList.ReadOnly(System.Collections.IList) +M:System.Collections.ArrayList.Remove(System.Object) +M:System.Collections.ArrayList.RemoveAt(System.Int32) +M:System.Collections.ArrayList.RemoveRange(System.Int32,System.Int32) +M:System.Collections.ArrayList.Repeat(System.Object,System.Int32) +M:System.Collections.ArrayList.Reverse +M:System.Collections.ArrayList.Reverse(System.Int32,System.Int32) +M:System.Collections.ArrayList.set_Capacity(System.Int32) +M:System.Collections.ArrayList.set_Item(System.Int32,System.Object) +M:System.Collections.ArrayList.SetRange(System.Int32,System.Collections.ICollection) +M:System.Collections.ArrayList.Sort +M:System.Collections.ArrayList.Sort(System.Collections.IComparer) +M:System.Collections.ArrayList.Sort(System.Int32,System.Int32,System.Collections.IComparer) +M:System.Collections.ArrayList.Synchronized(System.Collections.ArrayList) +M:System.Collections.ArrayList.Synchronized(System.Collections.IList) +M:System.Collections.ArrayList.ToArray +M:System.Collections.ArrayList.ToArray(System.Type) +M:System.Collections.ArrayList.TrimToSize +M:System.Collections.Comparer.#ctor(System.Globalization.CultureInfo) +M:System.Collections.Comparer.Compare(System.Object,System.Object) +M:System.Collections.Comparer.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.DictionaryEntry.#ctor(System.Object,System.Object) +M:System.Collections.DictionaryEntry.Deconstruct(System.Object@,System.Object@) +M:System.Collections.DictionaryEntry.get_Key +M:System.Collections.DictionaryEntry.get_Value +M:System.Collections.DictionaryEntry.set_Key(System.Object) +M:System.Collections.DictionaryEntry.set_Value(System.Object) +M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken) +M:System.Collections.Generic.IAsyncEnumerator`1.get_Current +M:System.Collections.Generic.IAsyncEnumerator`1.MoveNextAsync +M:System.Collections.Generic.ICollection`1.Add(`0) +M:System.Collections.Generic.ICollection`1.Clear +M:System.Collections.Generic.ICollection`1.Contains(`0) +M:System.Collections.Generic.ICollection`1.CopyTo(`0[],System.Int32) +M:System.Collections.Generic.ICollection`1.get_Count +M:System.Collections.Generic.ICollection`1.get_IsReadOnly +M:System.Collections.Generic.ICollection`1.Remove(`0) +M:System.Collections.Generic.IComparer`1.Compare(`0,`0) +M:System.Collections.Generic.IDictionary`2.Add(`0,`1) +M:System.Collections.Generic.IDictionary`2.ContainsKey(`0) +M:System.Collections.Generic.IDictionary`2.get_Item(`0) +M:System.Collections.Generic.IDictionary`2.get_Keys +M:System.Collections.Generic.IDictionary`2.get_Values +M:System.Collections.Generic.IDictionary`2.Remove(`0) +M:System.Collections.Generic.IDictionary`2.set_Item(`0,`1) +M:System.Collections.Generic.IDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Generic.IEnumerable`1.GetEnumerator +M:System.Collections.Generic.IEnumerator`1.get_Current +M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0) +M:System.Collections.Generic.IEqualityComparer`1.GetHashCode(`0) +M:System.Collections.Generic.IList`1.get_Item(System.Int32) +M:System.Collections.Generic.IList`1.IndexOf(`0) +M:System.Collections.Generic.IList`1.Insert(System.Int32,`0) +M:System.Collections.Generic.IList`1.RemoveAt(System.Int32) +M:System.Collections.Generic.IList`1.set_Item(System.Int32,`0) +M:System.Collections.Generic.IReadOnlyCollection`1.get_Count +M:System.Collections.Generic.IReadOnlyDictionary`2.ContainsKey(`0) +M:System.Collections.Generic.IReadOnlyDictionary`2.get_Item(`0) +M:System.Collections.Generic.IReadOnlyDictionary`2.get_Keys +M:System.Collections.Generic.IReadOnlyDictionary`2.get_Values +M:System.Collections.Generic.IReadOnlyDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.Generic.IReadOnlyList`1.get_Item(System.Int32) +M:System.Collections.Generic.IReadOnlySet`1.Contains(`0) +M:System.Collections.Generic.IReadOnlySet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.IReadOnlySet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.IReadOnlySet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.IReadOnlySet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.IReadOnlySet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.IReadOnlySet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.Add(`0) +M:System.Collections.Generic.ISet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.ISet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) +M:System.Collections.Generic.KeyNotFoundException.#ctor +M:System.Collections.Generic.KeyNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Generic.KeyNotFoundException.#ctor(System.String) +M:System.Collections.Generic.KeyNotFoundException.#ctor(System.String,System.Exception) +M:System.Collections.Generic.KeyValuePair.Create``2(``0,``1) +M:System.Collections.Generic.KeyValuePair`2.#ctor(`0,`1) +M:System.Collections.Generic.KeyValuePair`2.Deconstruct(`0@,`1@) +M:System.Collections.Generic.KeyValuePair`2.get_Key +M:System.Collections.Generic.KeyValuePair`2.get_Value +M:System.Collections.Generic.KeyValuePair`2.ToString +M:System.Collections.Hashtable.#ctor +M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary) +M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IEqualityComparer) +M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IHashCodeProvider,System.Collections.IComparer) +M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single) +M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single,System.Collections.IEqualityComparer) +M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single,System.Collections.IHashCodeProvider,System.Collections.IComparer) +M:System.Collections.Hashtable.#ctor(System.Collections.IEqualityComparer) +M:System.Collections.Hashtable.#ctor(System.Collections.IHashCodeProvider,System.Collections.IComparer) +M:System.Collections.Hashtable.#ctor(System.Int32) +M:System.Collections.Hashtable.#ctor(System.Int32,System.Collections.IEqualityComparer) +M:System.Collections.Hashtable.#ctor(System.Int32,System.Collections.IHashCodeProvider,System.Collections.IComparer) +M:System.Collections.Hashtable.#ctor(System.Int32,System.Single) +M:System.Collections.Hashtable.#ctor(System.Int32,System.Single,System.Collections.IEqualityComparer) +M:System.Collections.Hashtable.#ctor(System.Int32,System.Single,System.Collections.IHashCodeProvider,System.Collections.IComparer) +M:System.Collections.Hashtable.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Hashtable.Add(System.Object,System.Object) +M:System.Collections.Hashtable.Clear +M:System.Collections.Hashtable.Clone +M:System.Collections.Hashtable.Contains(System.Object) +M:System.Collections.Hashtable.ContainsKey(System.Object) +M:System.Collections.Hashtable.ContainsValue(System.Object) +M:System.Collections.Hashtable.CopyTo(System.Array,System.Int32) +M:System.Collections.Hashtable.get_comparer +M:System.Collections.Hashtable.get_Count +M:System.Collections.Hashtable.get_EqualityComparer +M:System.Collections.Hashtable.get_hcp +M:System.Collections.Hashtable.get_IsFixedSize +M:System.Collections.Hashtable.get_IsReadOnly +M:System.Collections.Hashtable.get_IsSynchronized +M:System.Collections.Hashtable.get_Item(System.Object) +M:System.Collections.Hashtable.get_Keys +M:System.Collections.Hashtable.get_SyncRoot +M:System.Collections.Hashtable.get_Values +M:System.Collections.Hashtable.GetEnumerator +M:System.Collections.Hashtable.GetHash(System.Object) +M:System.Collections.Hashtable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Collections.Hashtable.KeyEquals(System.Object,System.Object) +M:System.Collections.Hashtable.OnDeserialization(System.Object) +M:System.Collections.Hashtable.Remove(System.Object) +M:System.Collections.Hashtable.set_comparer(System.Collections.IComparer) +M:System.Collections.Hashtable.set_hcp(System.Collections.IHashCodeProvider) +M:System.Collections.Hashtable.set_Item(System.Object,System.Object) +M:System.Collections.Hashtable.Synchronized(System.Collections.Hashtable) +M:System.Collections.ICollection.CopyTo(System.Array,System.Int32) +M:System.Collections.ICollection.get_Count +M:System.Collections.ICollection.get_IsSynchronized +M:System.Collections.ICollection.get_SyncRoot +M:System.Collections.IComparer.Compare(System.Object,System.Object) +M:System.Collections.IDictionary.Add(System.Object,System.Object) +M:System.Collections.IDictionary.Clear +M:System.Collections.IDictionary.Contains(System.Object) +M:System.Collections.IDictionary.get_IsFixedSize +M:System.Collections.IDictionary.get_IsReadOnly +M:System.Collections.IDictionary.get_Item(System.Object) +M:System.Collections.IDictionary.get_Keys +M:System.Collections.IDictionary.get_Values +M:System.Collections.IDictionary.GetEnumerator +M:System.Collections.IDictionary.Remove(System.Object) +M:System.Collections.IDictionary.set_Item(System.Object,System.Object) +M:System.Collections.IDictionaryEnumerator.get_Entry +M:System.Collections.IDictionaryEnumerator.get_Key +M:System.Collections.IDictionaryEnumerator.get_Value +M:System.Collections.IEnumerable.GetEnumerator +M:System.Collections.IEnumerator.get_Current +M:System.Collections.IEnumerator.MoveNext +M:System.Collections.IEnumerator.Reset +M:System.Collections.IEqualityComparer.Equals(System.Object,System.Object) +M:System.Collections.IEqualityComparer.GetHashCode(System.Object) +M:System.Collections.IHashCodeProvider.GetHashCode(System.Object) +M:System.Collections.IList.Add(System.Object) +M:System.Collections.IList.Clear +M:System.Collections.IList.Contains(System.Object) +M:System.Collections.IList.get_IsFixedSize +M:System.Collections.IList.get_IsReadOnly +M:System.Collections.IList.get_Item(System.Int32) +M:System.Collections.IList.IndexOf(System.Object) +M:System.Collections.IList.Insert(System.Int32,System.Object) +M:System.Collections.IList.Remove(System.Object) +M:System.Collections.IList.RemoveAt(System.Int32) +M:System.Collections.IList.set_Item(System.Int32,System.Object) +M:System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer) +M:System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer) +M:System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer) +M:System.Collections.ObjectModel.Collection`1.#ctor +M:System.Collections.ObjectModel.Collection`1.#ctor(System.Collections.Generic.IList{`0}) +M:System.Collections.ObjectModel.Collection`1.Add(`0) +M:System.Collections.ObjectModel.Collection`1.Clear +M:System.Collections.ObjectModel.Collection`1.ClearItems +M:System.Collections.ObjectModel.Collection`1.Contains(`0) +M:System.Collections.ObjectModel.Collection`1.CopyTo(`0[],System.Int32) +M:System.Collections.ObjectModel.Collection`1.get_Count +M:System.Collections.ObjectModel.Collection`1.get_Item(System.Int32) +M:System.Collections.ObjectModel.Collection`1.get_Items +M:System.Collections.ObjectModel.Collection`1.GetEnumerator +M:System.Collections.ObjectModel.Collection`1.IndexOf(`0) +M:System.Collections.ObjectModel.Collection`1.Insert(System.Int32,`0) +M:System.Collections.ObjectModel.Collection`1.InsertItem(System.Int32,`0) +M:System.Collections.ObjectModel.Collection`1.Remove(`0) +M:System.Collections.ObjectModel.Collection`1.RemoveAt(System.Int32) +M:System.Collections.ObjectModel.Collection`1.RemoveItem(System.Int32) +M:System.Collections.ObjectModel.Collection`1.set_Item(System.Int32,`0) +M:System.Collections.ObjectModel.Collection`1.SetItem(System.Int32,`0) +M:System.Collections.ObjectModel.ReadOnlyCollection`1.#ctor(System.Collections.Generic.IList{`0}) +M:System.Collections.ObjectModel.ReadOnlyCollection`1.Contains(`0) +M:System.Collections.ObjectModel.ReadOnlyCollection`1.CopyTo(`0[],System.Int32) +M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Count +M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Empty +M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Item(System.Int32) +M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Items +M:System.Collections.ObjectModel.ReadOnlyCollection`1.GetEnumerator +M:System.Collections.ObjectModel.ReadOnlyCollection`1.IndexOf(`0) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ContainsKey(`0) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Count +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Dictionary +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Empty +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Item(`0) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Keys +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Values +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.GetEnumerator +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.Contains(`0) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.get_Count +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.GetEnumerator +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.TryGetValue(`0,`1@) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.get_Count +M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.GetEnumerator +M:System.Comparison`1.#ctor(System.Object,System.IntPtr) +M:System.Comparison`1.BeginInvoke(`0,`0,System.AsyncCallback,System.Object) +M:System.Comparison`1.EndInvoke(System.IAsyncResult) +M:System.Comparison`1.Invoke(`0,`0) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Boolean) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Byte) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Char) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Double) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Int16) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Int32) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Int64) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Object) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.SByte) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Single) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.String) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Type,System.String) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt16) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt32) +M:System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt64) +M:System.ComponentModel.DefaultValueAttribute.Equals(System.Object) +M:System.ComponentModel.DefaultValueAttribute.get_Value +M:System.ComponentModel.DefaultValueAttribute.GetHashCode +M:System.ComponentModel.DefaultValueAttribute.SetValue(System.Object) +M:System.ComponentModel.EditorBrowsableAttribute.#ctor +M:System.ComponentModel.EditorBrowsableAttribute.#ctor(System.ComponentModel.EditorBrowsableState) +M:System.ComponentModel.EditorBrowsableAttribute.Equals(System.Object) +M:System.ComponentModel.EditorBrowsableAttribute.get_State +M:System.ComponentModel.EditorBrowsableAttribute.GetHashCode +M:System.ContextBoundObject.#ctor +M:System.ContextMarshalException.#ctor +M:System.ContextMarshalException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ContextMarshalException.#ctor(System.String) +M:System.ContextMarshalException.#ctor(System.String,System.Exception) +M:System.ContextStaticAttribute.#ctor +M:System.Convert.ChangeType(System.Object,System.Type) +M:System.Convert.ChangeType(System.Object,System.Type,System.IFormatProvider) +M:System.Convert.ChangeType(System.Object,System.TypeCode) +M:System.Convert.ChangeType(System.Object,System.TypeCode,System.IFormatProvider) +M:System.Convert.FromBase64CharArray(System.Char[],System.Int32,System.Int32) +M:System.Convert.FromBase64String(System.String) +M:System.Convert.FromHexString(System.ReadOnlySpan{System.Char}) +M:System.Convert.FromHexString(System.String) +M:System.Convert.GetTypeCode(System.Object) +M:System.Convert.IsDBNull(System.Object) +M:System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) +M:System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Base64FormattingOptions) +M:System.Convert.ToBase64String(System.Byte[]) +M:System.Convert.ToBase64String(System.Byte[],System.Base64FormattingOptions) +M:System.Convert.ToBase64String(System.Byte[],System.Int32,System.Int32) +M:System.Convert.ToBase64String(System.Byte[],System.Int32,System.Int32,System.Base64FormattingOptions) +M:System.Convert.ToBase64String(System.ReadOnlySpan{System.Byte},System.Base64FormattingOptions) +M:System.Convert.ToBoolean(System.Boolean) +M:System.Convert.ToBoolean(System.Byte) +M:System.Convert.ToBoolean(System.Char) +M:System.Convert.ToBoolean(System.DateTime) +M:System.Convert.ToBoolean(System.Decimal) +M:System.Convert.ToBoolean(System.Double) +M:System.Convert.ToBoolean(System.Int16) +M:System.Convert.ToBoolean(System.Int32) +M:System.Convert.ToBoolean(System.Int64) +M:System.Convert.ToBoolean(System.Object) +M:System.Convert.ToBoolean(System.Object,System.IFormatProvider) +M:System.Convert.ToBoolean(System.SByte) +M:System.Convert.ToBoolean(System.Single) +M:System.Convert.ToBoolean(System.String) +M:System.Convert.ToBoolean(System.String,System.IFormatProvider) +M:System.Convert.ToBoolean(System.UInt16) +M:System.Convert.ToBoolean(System.UInt32) +M:System.Convert.ToBoolean(System.UInt64) +M:System.Convert.ToByte(System.Boolean) +M:System.Convert.ToByte(System.Byte) +M:System.Convert.ToByte(System.Char) +M:System.Convert.ToByte(System.DateTime) +M:System.Convert.ToByte(System.Decimal) +M:System.Convert.ToByte(System.Double) +M:System.Convert.ToByte(System.Int16) +M:System.Convert.ToByte(System.Int32) +M:System.Convert.ToByte(System.Int64) +M:System.Convert.ToByte(System.Object) +M:System.Convert.ToByte(System.Object,System.IFormatProvider) +M:System.Convert.ToByte(System.SByte) +M:System.Convert.ToByte(System.Single) +M:System.Convert.ToByte(System.String) +M:System.Convert.ToByte(System.String,System.IFormatProvider) +M:System.Convert.ToByte(System.String,System.Int32) +M:System.Convert.ToByte(System.UInt16) +M:System.Convert.ToByte(System.UInt32) +M:System.Convert.ToByte(System.UInt64) +M:System.Convert.ToChar(System.Boolean) +M:System.Convert.ToChar(System.Byte) +M:System.Convert.ToChar(System.Char) +M:System.Convert.ToChar(System.DateTime) +M:System.Convert.ToChar(System.Decimal) +M:System.Convert.ToChar(System.Double) +M:System.Convert.ToChar(System.Int16) +M:System.Convert.ToChar(System.Int32) +M:System.Convert.ToChar(System.Int64) +M:System.Convert.ToChar(System.Object) +M:System.Convert.ToChar(System.Object,System.IFormatProvider) +M:System.Convert.ToChar(System.SByte) +M:System.Convert.ToChar(System.Single) +M:System.Convert.ToChar(System.String) +M:System.Convert.ToChar(System.String,System.IFormatProvider) +M:System.Convert.ToChar(System.UInt16) +M:System.Convert.ToChar(System.UInt32) +M:System.Convert.ToChar(System.UInt64) +M:System.Convert.ToDateTime(System.Boolean) +M:System.Convert.ToDateTime(System.Byte) +M:System.Convert.ToDateTime(System.Char) +M:System.Convert.ToDateTime(System.DateTime) +M:System.Convert.ToDateTime(System.Decimal) +M:System.Convert.ToDateTime(System.Double) +M:System.Convert.ToDateTime(System.Int16) +M:System.Convert.ToDateTime(System.Int32) +M:System.Convert.ToDateTime(System.Int64) +M:System.Convert.ToDateTime(System.Object) +M:System.Convert.ToDateTime(System.Object,System.IFormatProvider) +M:System.Convert.ToDateTime(System.SByte) +M:System.Convert.ToDateTime(System.Single) +M:System.Convert.ToDateTime(System.String) +M:System.Convert.ToDateTime(System.String,System.IFormatProvider) +M:System.Convert.ToDateTime(System.UInt16) +M:System.Convert.ToDateTime(System.UInt32) +M:System.Convert.ToDateTime(System.UInt64) +M:System.Convert.ToDecimal(System.Boolean) +M:System.Convert.ToDecimal(System.Byte) +M:System.Convert.ToDecimal(System.Char) +M:System.Convert.ToDecimal(System.DateTime) +M:System.Convert.ToDecimal(System.Decimal) +M:System.Convert.ToDecimal(System.Double) +M:System.Convert.ToDecimal(System.Int16) +M:System.Convert.ToDecimal(System.Int32) +M:System.Convert.ToDecimal(System.Int64) +M:System.Convert.ToDecimal(System.Object) +M:System.Convert.ToDecimal(System.Object,System.IFormatProvider) +M:System.Convert.ToDecimal(System.SByte) +M:System.Convert.ToDecimal(System.Single) +M:System.Convert.ToDecimal(System.String) +M:System.Convert.ToDecimal(System.String,System.IFormatProvider) +M:System.Convert.ToDecimal(System.UInt16) +M:System.Convert.ToDecimal(System.UInt32) +M:System.Convert.ToDecimal(System.UInt64) +M:System.Convert.ToDouble(System.Boolean) +M:System.Convert.ToDouble(System.Byte) +M:System.Convert.ToDouble(System.Char) +M:System.Convert.ToDouble(System.DateTime) +M:System.Convert.ToDouble(System.Decimal) +M:System.Convert.ToDouble(System.Double) +M:System.Convert.ToDouble(System.Int16) +M:System.Convert.ToDouble(System.Int32) +M:System.Convert.ToDouble(System.Int64) +M:System.Convert.ToDouble(System.Object) +M:System.Convert.ToDouble(System.Object,System.IFormatProvider) +M:System.Convert.ToDouble(System.SByte) +M:System.Convert.ToDouble(System.Single) +M:System.Convert.ToDouble(System.String) +M:System.Convert.ToDouble(System.String,System.IFormatProvider) +M:System.Convert.ToDouble(System.UInt16) +M:System.Convert.ToDouble(System.UInt32) +M:System.Convert.ToDouble(System.UInt64) +M:System.Convert.ToHexString(System.Byte[]) +M:System.Convert.ToHexString(System.Byte[],System.Int32,System.Int32) +M:System.Convert.ToHexString(System.ReadOnlySpan{System.Byte}) +M:System.Convert.ToInt16(System.Boolean) +M:System.Convert.ToInt16(System.Byte) +M:System.Convert.ToInt16(System.Char) +M:System.Convert.ToInt16(System.DateTime) +M:System.Convert.ToInt16(System.Decimal) +M:System.Convert.ToInt16(System.Double) +M:System.Convert.ToInt16(System.Int16) +M:System.Convert.ToInt16(System.Int32) +M:System.Convert.ToInt16(System.Int64) +M:System.Convert.ToInt16(System.Object) +M:System.Convert.ToInt16(System.Object,System.IFormatProvider) +M:System.Convert.ToInt16(System.SByte) +M:System.Convert.ToInt16(System.Single) +M:System.Convert.ToInt16(System.String) +M:System.Convert.ToInt16(System.String,System.IFormatProvider) +M:System.Convert.ToInt16(System.String,System.Int32) +M:System.Convert.ToInt16(System.UInt16) +M:System.Convert.ToInt16(System.UInt32) +M:System.Convert.ToInt16(System.UInt64) +M:System.Convert.ToInt32(System.Boolean) +M:System.Convert.ToInt32(System.Byte) +M:System.Convert.ToInt32(System.Char) +M:System.Convert.ToInt32(System.DateTime) +M:System.Convert.ToInt32(System.Decimal) +M:System.Convert.ToInt32(System.Double) +M:System.Convert.ToInt32(System.Int16) +M:System.Convert.ToInt32(System.Int32) +M:System.Convert.ToInt32(System.Int64) +M:System.Convert.ToInt32(System.Object) +M:System.Convert.ToInt32(System.Object,System.IFormatProvider) +M:System.Convert.ToInt32(System.SByte) +M:System.Convert.ToInt32(System.Single) +M:System.Convert.ToInt32(System.String) +M:System.Convert.ToInt32(System.String,System.IFormatProvider) +M:System.Convert.ToInt32(System.String,System.Int32) +M:System.Convert.ToInt32(System.UInt16) +M:System.Convert.ToInt32(System.UInt32) +M:System.Convert.ToInt32(System.UInt64) +M:System.Convert.ToInt64(System.Boolean) +M:System.Convert.ToInt64(System.Byte) +M:System.Convert.ToInt64(System.Char) +M:System.Convert.ToInt64(System.DateTime) +M:System.Convert.ToInt64(System.Decimal) +M:System.Convert.ToInt64(System.Double) +M:System.Convert.ToInt64(System.Int16) +M:System.Convert.ToInt64(System.Int32) +M:System.Convert.ToInt64(System.Int64) +M:System.Convert.ToInt64(System.Object) +M:System.Convert.ToInt64(System.Object,System.IFormatProvider) +M:System.Convert.ToInt64(System.SByte) +M:System.Convert.ToInt64(System.Single) +M:System.Convert.ToInt64(System.String) +M:System.Convert.ToInt64(System.String,System.IFormatProvider) +M:System.Convert.ToInt64(System.String,System.Int32) +M:System.Convert.ToInt64(System.UInt16) +M:System.Convert.ToInt64(System.UInt32) +M:System.Convert.ToInt64(System.UInt64) +M:System.Convert.ToSByte(System.Boolean) +M:System.Convert.ToSByte(System.Byte) +M:System.Convert.ToSByte(System.Char) +M:System.Convert.ToSByte(System.DateTime) +M:System.Convert.ToSByte(System.Decimal) +M:System.Convert.ToSByte(System.Double) +M:System.Convert.ToSByte(System.Int16) +M:System.Convert.ToSByte(System.Int32) +M:System.Convert.ToSByte(System.Int64) +M:System.Convert.ToSByte(System.Object) +M:System.Convert.ToSByte(System.Object,System.IFormatProvider) +M:System.Convert.ToSByte(System.SByte) +M:System.Convert.ToSByte(System.Single) +M:System.Convert.ToSByte(System.String) +M:System.Convert.ToSByte(System.String,System.IFormatProvider) +M:System.Convert.ToSByte(System.String,System.Int32) +M:System.Convert.ToSByte(System.UInt16) +M:System.Convert.ToSByte(System.UInt32) +M:System.Convert.ToSByte(System.UInt64) +M:System.Convert.ToSingle(System.Boolean) +M:System.Convert.ToSingle(System.Byte) +M:System.Convert.ToSingle(System.Char) +M:System.Convert.ToSingle(System.DateTime) +M:System.Convert.ToSingle(System.Decimal) +M:System.Convert.ToSingle(System.Double) +M:System.Convert.ToSingle(System.Int16) +M:System.Convert.ToSingle(System.Int32) +M:System.Convert.ToSingle(System.Int64) +M:System.Convert.ToSingle(System.Object) +M:System.Convert.ToSingle(System.Object,System.IFormatProvider) +M:System.Convert.ToSingle(System.SByte) +M:System.Convert.ToSingle(System.Single) +M:System.Convert.ToSingle(System.String) +M:System.Convert.ToSingle(System.String,System.IFormatProvider) +M:System.Convert.ToSingle(System.UInt16) +M:System.Convert.ToSingle(System.UInt32) +M:System.Convert.ToSingle(System.UInt64) +M:System.Convert.ToString(System.Boolean) +M:System.Convert.ToString(System.Boolean,System.IFormatProvider) +M:System.Convert.ToString(System.Byte) +M:System.Convert.ToString(System.Byte,System.IFormatProvider) +M:System.Convert.ToString(System.Byte,System.Int32) +M:System.Convert.ToString(System.Char) +M:System.Convert.ToString(System.Char,System.IFormatProvider) +M:System.Convert.ToString(System.DateTime) +M:System.Convert.ToString(System.DateTime,System.IFormatProvider) +M:System.Convert.ToString(System.Decimal) +M:System.Convert.ToString(System.Decimal,System.IFormatProvider) +M:System.Convert.ToString(System.Double) +M:System.Convert.ToString(System.Double,System.IFormatProvider) +M:System.Convert.ToString(System.Int16) +M:System.Convert.ToString(System.Int16,System.IFormatProvider) +M:System.Convert.ToString(System.Int16,System.Int32) +M:System.Convert.ToString(System.Int32) +M:System.Convert.ToString(System.Int32,System.IFormatProvider) +M:System.Convert.ToString(System.Int32,System.Int32) +M:System.Convert.ToString(System.Int64) +M:System.Convert.ToString(System.Int64,System.IFormatProvider) +M:System.Convert.ToString(System.Int64,System.Int32) +M:System.Convert.ToString(System.Object) +M:System.Convert.ToString(System.Object,System.IFormatProvider) +M:System.Convert.ToString(System.SByte) +M:System.Convert.ToString(System.SByte,System.IFormatProvider) +M:System.Convert.ToString(System.Single) +M:System.Convert.ToString(System.Single,System.IFormatProvider) +M:System.Convert.ToString(System.String) +M:System.Convert.ToString(System.String,System.IFormatProvider) +M:System.Convert.ToString(System.UInt16) +M:System.Convert.ToString(System.UInt16,System.IFormatProvider) +M:System.Convert.ToString(System.UInt32) +M:System.Convert.ToString(System.UInt32,System.IFormatProvider) +M:System.Convert.ToString(System.UInt64) +M:System.Convert.ToString(System.UInt64,System.IFormatProvider) +M:System.Convert.ToUInt16(System.Boolean) +M:System.Convert.ToUInt16(System.Byte) +M:System.Convert.ToUInt16(System.Char) +M:System.Convert.ToUInt16(System.DateTime) +M:System.Convert.ToUInt16(System.Decimal) +M:System.Convert.ToUInt16(System.Double) +M:System.Convert.ToUInt16(System.Int16) +M:System.Convert.ToUInt16(System.Int32) +M:System.Convert.ToUInt16(System.Int64) +M:System.Convert.ToUInt16(System.Object) +M:System.Convert.ToUInt16(System.Object,System.IFormatProvider) +M:System.Convert.ToUInt16(System.SByte) +M:System.Convert.ToUInt16(System.Single) +M:System.Convert.ToUInt16(System.String) +M:System.Convert.ToUInt16(System.String,System.IFormatProvider) +M:System.Convert.ToUInt16(System.String,System.Int32) +M:System.Convert.ToUInt16(System.UInt16) +M:System.Convert.ToUInt16(System.UInt32) +M:System.Convert.ToUInt16(System.UInt64) +M:System.Convert.ToUInt32(System.Boolean) +M:System.Convert.ToUInt32(System.Byte) +M:System.Convert.ToUInt32(System.Char) +M:System.Convert.ToUInt32(System.DateTime) +M:System.Convert.ToUInt32(System.Decimal) +M:System.Convert.ToUInt32(System.Double) +M:System.Convert.ToUInt32(System.Int16) +M:System.Convert.ToUInt32(System.Int32) +M:System.Convert.ToUInt32(System.Int64) +M:System.Convert.ToUInt32(System.Object) +M:System.Convert.ToUInt32(System.Object,System.IFormatProvider) +M:System.Convert.ToUInt32(System.SByte) +M:System.Convert.ToUInt32(System.Single) +M:System.Convert.ToUInt32(System.String) +M:System.Convert.ToUInt32(System.String,System.IFormatProvider) +M:System.Convert.ToUInt32(System.String,System.Int32) +M:System.Convert.ToUInt32(System.UInt16) +M:System.Convert.ToUInt32(System.UInt32) +M:System.Convert.ToUInt32(System.UInt64) +M:System.Convert.ToUInt64(System.Boolean) +M:System.Convert.ToUInt64(System.Byte) +M:System.Convert.ToUInt64(System.Char) +M:System.Convert.ToUInt64(System.DateTime) +M:System.Convert.ToUInt64(System.Decimal) +M:System.Convert.ToUInt64(System.Double) +M:System.Convert.ToUInt64(System.Int16) +M:System.Convert.ToUInt64(System.Int32) +M:System.Convert.ToUInt64(System.Int64) +M:System.Convert.ToUInt64(System.Object) +M:System.Convert.ToUInt64(System.Object,System.IFormatProvider) +M:System.Convert.ToUInt64(System.SByte) +M:System.Convert.ToUInt64(System.Single) +M:System.Convert.ToUInt64(System.String) +M:System.Convert.ToUInt64(System.String,System.IFormatProvider) +M:System.Convert.ToUInt64(System.String,System.Int32) +M:System.Convert.ToUInt64(System.UInt16) +M:System.Convert.ToUInt64(System.UInt32) +M:System.Convert.ToUInt64(System.UInt64) +M:System.Convert.TryFromBase64Chars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +M:System.Convert.TryFromBase64String(System.String,System.Span{System.Byte},System.Int32@) +M:System.Convert.TryToBase64Chars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Base64FormattingOptions) +M:System.Converter`2.#ctor(System.Object,System.IntPtr) +M:System.Converter`2.BeginInvoke(`0,System.AsyncCallback,System.Object) +M:System.Converter`2.EndInvoke(System.IAsyncResult) +M:System.Converter`2.Invoke(`0) +M:System.DateOnly.#ctor(System.Int32,System.Int32,System.Int32) +M:System.DateOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +M:System.DateOnly.AddDays(System.Int32) +M:System.DateOnly.AddMonths(System.Int32) +M:System.DateOnly.AddYears(System.Int32) +M:System.DateOnly.CompareTo(System.DateOnly) +M:System.DateOnly.CompareTo(System.Object) +M:System.DateOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@) +M:System.DateOnly.Equals(System.DateOnly) +M:System.DateOnly.Equals(System.Object) +M:System.DateOnly.FromDateTime(System.DateTime) +M:System.DateOnly.FromDayNumber(System.Int32) +M:System.DateOnly.get_Day +M:System.DateOnly.get_DayNumber +M:System.DateOnly.get_DayOfWeek +M:System.DateOnly.get_DayOfYear +M:System.DateOnly.get_MaxValue +M:System.DateOnly.get_MinValue +M:System.DateOnly.get_Month +M:System.DateOnly.get_Year +M:System.DateOnly.GetHashCode +M:System.DateOnly.op_Equality(System.DateOnly,System.DateOnly) +M:System.DateOnly.op_GreaterThan(System.DateOnly,System.DateOnly) +M:System.DateOnly.op_GreaterThanOrEqual(System.DateOnly,System.DateOnly) +M:System.DateOnly.op_Inequality(System.DateOnly,System.DateOnly) +M:System.DateOnly.op_LessThan(System.DateOnly,System.DateOnly) +M:System.DateOnly.op_LessThanOrEqual(System.DateOnly,System.DateOnly) +M:System.DateOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateOnly.Parse(System.String) +M:System.DateOnly.Parse(System.String,System.IFormatProvider) +M:System.DateOnly.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[]) +M:System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateOnly.ParseExact(System.String,System.String) +M:System.DateOnly.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateOnly.ParseExact(System.String,System.String[]) +M:System.DateOnly.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateOnly.ToDateTime(System.TimeOnly) +M:System.DateOnly.ToDateTime(System.TimeOnly,System.DateTimeKind) +M:System.DateOnly.ToLongDateString +M:System.DateOnly.ToShortDateString +M:System.DateOnly.ToString +M:System.DateOnly.ToString(System.IFormatProvider) +M:System.DateOnly.ToString(System.String) +M:System.DateOnly.ToString(System.String,System.IFormatProvider) +M:System.DateOnly.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateOnly.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.DateOnly@) +M:System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateOnly@) +M:System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +M:System.DateOnly.TryParse(System.String,System.DateOnly@) +M:System.DateOnly.TryParse(System.String,System.IFormatProvider,System.DateOnly@) +M:System.DateOnly.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.DateOnly@) +M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.DateOnly@) +M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +M:System.DateOnly.TryParseExact(System.String,System.String,System.DateOnly@) +M:System.DateOnly.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +M:System.DateOnly.TryParseExact(System.String,System.String[],System.DateOnly@) +M:System.DateOnly.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) +M:System.DateTime.#ctor(System.DateOnly,System.TimeOnly) +M:System.DateTime.#ctor(System.DateOnly,System.TimeOnly,System.DateTimeKind) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) +M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind) +M:System.DateTime.#ctor(System.Int64) +M:System.DateTime.#ctor(System.Int64,System.DateTimeKind) +M:System.DateTime.Add(System.TimeSpan) +M:System.DateTime.AddDays(System.Double) +M:System.DateTime.AddHours(System.Double) +M:System.DateTime.AddMicroseconds(System.Double) +M:System.DateTime.AddMilliseconds(System.Double) +M:System.DateTime.AddMinutes(System.Double) +M:System.DateTime.AddMonths(System.Int32) +M:System.DateTime.AddSeconds(System.Double) +M:System.DateTime.AddTicks(System.Int64) +M:System.DateTime.AddYears(System.Int32) +M:System.DateTime.Compare(System.DateTime,System.DateTime) +M:System.DateTime.CompareTo(System.DateTime) +M:System.DateTime.CompareTo(System.Object) +M:System.DateTime.DaysInMonth(System.Int32,System.Int32) +M:System.DateTime.Deconstruct(System.DateOnly@,System.TimeOnly@) +M:System.DateTime.Deconstruct(System.Int32@,System.Int32@,System.Int32@) +M:System.DateTime.Equals(System.DateTime) +M:System.DateTime.Equals(System.DateTime,System.DateTime) +M:System.DateTime.Equals(System.Object) +M:System.DateTime.FromBinary(System.Int64) +M:System.DateTime.FromFileTime(System.Int64) +M:System.DateTime.FromFileTimeUtc(System.Int64) +M:System.DateTime.FromOADate(System.Double) +M:System.DateTime.get_Date +M:System.DateTime.get_Day +M:System.DateTime.get_DayOfWeek +M:System.DateTime.get_DayOfYear +M:System.DateTime.get_Hour +M:System.DateTime.get_Kind +M:System.DateTime.get_Microsecond +M:System.DateTime.get_Millisecond +M:System.DateTime.get_Minute +M:System.DateTime.get_Month +M:System.DateTime.get_Nanosecond +M:System.DateTime.get_Now +M:System.DateTime.get_Second +M:System.DateTime.get_Ticks +M:System.DateTime.get_TimeOfDay +M:System.DateTime.get_Today +M:System.DateTime.get_UtcNow +M:System.DateTime.get_Year +M:System.DateTime.GetDateTimeFormats +M:System.DateTime.GetDateTimeFormats(System.Char) +M:System.DateTime.GetDateTimeFormats(System.Char,System.IFormatProvider) +M:System.DateTime.GetDateTimeFormats(System.IFormatProvider) +M:System.DateTime.GetHashCode +M:System.DateTime.GetTypeCode +M:System.DateTime.IsDaylightSavingTime +M:System.DateTime.IsLeapYear(System.Int32) +M:System.DateTime.op_Addition(System.DateTime,System.TimeSpan) +M:System.DateTime.op_Equality(System.DateTime,System.DateTime) +M:System.DateTime.op_GreaterThan(System.DateTime,System.DateTime) +M:System.DateTime.op_GreaterThanOrEqual(System.DateTime,System.DateTime) +M:System.DateTime.op_Inequality(System.DateTime,System.DateTime) +M:System.DateTime.op_LessThan(System.DateTime,System.DateTime) +M:System.DateTime.op_LessThanOrEqual(System.DateTime,System.DateTime) +M:System.DateTime.op_Subtraction(System.DateTime,System.DateTime) +M:System.DateTime.op_Subtraction(System.DateTime,System.TimeSpan) +M:System.DateTime.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateTime.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTime.Parse(System.String) +M:System.DateTime.Parse(System.String,System.IFormatProvider) +M:System.DateTime.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTime.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTime.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTime.ParseExact(System.String,System.String,System.IFormatProvider) +M:System.DateTime.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTime.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTime.SpecifyKind(System.DateTime,System.DateTimeKind) +M:System.DateTime.Subtract(System.DateTime) +M:System.DateTime.Subtract(System.TimeSpan) +M:System.DateTime.ToBinary +M:System.DateTime.ToFileTime +M:System.DateTime.ToFileTimeUtc +M:System.DateTime.ToLocalTime +M:System.DateTime.ToLongDateString +M:System.DateTime.ToLongTimeString +M:System.DateTime.ToOADate +M:System.DateTime.ToShortDateString +M:System.DateTime.ToShortTimeString +M:System.DateTime.ToString +M:System.DateTime.ToString(System.IFormatProvider) +M:System.DateTime.ToString(System.String) +M:System.DateTime.ToString(System.String,System.IFormatProvider) +M:System.DateTime.ToUniversalTime +M:System.DateTime.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateTime.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.DateTime@) +M:System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateTime@) +M:System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +M:System.DateTime.TryParse(System.String,System.DateTime@) +M:System.DateTime.TryParse(System.String,System.IFormatProvider,System.DateTime@) +M:System.DateTime.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +M:System.DateTime.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +M:System.DateTime.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +M:System.DateTime.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +M:System.DateTime.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) +M:System.DateTimeOffset.#ctor(System.DateOnly,System.TimeOnly,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.DateTime) +M:System.DateTimeOffset.#ctor(System.DateTime,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) +M:System.DateTimeOffset.#ctor(System.Int64,System.TimeSpan) +M:System.DateTimeOffset.Add(System.TimeSpan) +M:System.DateTimeOffset.AddDays(System.Double) +M:System.DateTimeOffset.AddHours(System.Double) +M:System.DateTimeOffset.AddMicroseconds(System.Double) +M:System.DateTimeOffset.AddMilliseconds(System.Double) +M:System.DateTimeOffset.AddMinutes(System.Double) +M:System.DateTimeOffset.AddMonths(System.Int32) +M:System.DateTimeOffset.AddSeconds(System.Double) +M:System.DateTimeOffset.AddTicks(System.Int64) +M:System.DateTimeOffset.AddYears(System.Int32) +M:System.DateTimeOffset.Compare(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.CompareTo(System.DateTimeOffset) +M:System.DateTimeOffset.Deconstruct(System.DateOnly@,System.TimeOnly@,System.TimeSpan@) +M:System.DateTimeOffset.Equals(System.DateTimeOffset) +M:System.DateTimeOffset.Equals(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.Equals(System.Object) +M:System.DateTimeOffset.EqualsExact(System.DateTimeOffset) +M:System.DateTimeOffset.FromFileTime(System.Int64) +M:System.DateTimeOffset.FromUnixTimeMilliseconds(System.Int64) +M:System.DateTimeOffset.FromUnixTimeSeconds(System.Int64) +M:System.DateTimeOffset.get_Date +M:System.DateTimeOffset.get_DateTime +M:System.DateTimeOffset.get_Day +M:System.DateTimeOffset.get_DayOfWeek +M:System.DateTimeOffset.get_DayOfYear +M:System.DateTimeOffset.get_Hour +M:System.DateTimeOffset.get_LocalDateTime +M:System.DateTimeOffset.get_Microsecond +M:System.DateTimeOffset.get_Millisecond +M:System.DateTimeOffset.get_Minute +M:System.DateTimeOffset.get_Month +M:System.DateTimeOffset.get_Nanosecond +M:System.DateTimeOffset.get_Now +M:System.DateTimeOffset.get_Offset +M:System.DateTimeOffset.get_Second +M:System.DateTimeOffset.get_Ticks +M:System.DateTimeOffset.get_TimeOfDay +M:System.DateTimeOffset.get_TotalOffsetMinutes +M:System.DateTimeOffset.get_UtcDateTime +M:System.DateTimeOffset.get_UtcNow +M:System.DateTimeOffset.get_UtcTicks +M:System.DateTimeOffset.get_Year +M:System.DateTimeOffset.GetHashCode +M:System.DateTimeOffset.op_Addition(System.DateTimeOffset,System.TimeSpan) +M:System.DateTimeOffset.op_Equality(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_GreaterThan(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_GreaterThanOrEqual(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_Implicit(System.DateTime)~System.DateTimeOffset +M:System.DateTimeOffset.op_Inequality(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_LessThan(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_LessThanOrEqual(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_Subtraction(System.DateTimeOffset,System.DateTimeOffset) +M:System.DateTimeOffset.op_Subtraction(System.DateTimeOffset,System.TimeSpan) +M:System.DateTimeOffset.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateTimeOffset.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTimeOffset.Parse(System.String) +M:System.DateTimeOffset.Parse(System.String,System.IFormatProvider) +M:System.DateTimeOffset.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTimeOffset.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTimeOffset.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTimeOffset.ParseExact(System.String,System.String,System.IFormatProvider) +M:System.DateTimeOffset.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTimeOffset.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.DateTimeOffset.Subtract(System.DateTimeOffset) +M:System.DateTimeOffset.Subtract(System.TimeSpan) +M:System.DateTimeOffset.ToFileTime +M:System.DateTimeOffset.ToLocalTime +M:System.DateTimeOffset.ToOffset(System.TimeSpan) +M:System.DateTimeOffset.ToString +M:System.DateTimeOffset.ToString(System.IFormatProvider) +M:System.DateTimeOffset.ToString(System.String) +M:System.DateTimeOffset.ToString(System.String,System.IFormatProvider) +M:System.DateTimeOffset.ToUniversalTime +M:System.DateTimeOffset.ToUnixTimeMilliseconds +M:System.DateTimeOffset.ToUnixTimeSeconds +M:System.DateTimeOffset.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateTimeOffset.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.DateTimeOffset@) +M:System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParse(System.String,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParse(System.String,System.IFormatProvider,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +M:System.DateTimeOffset.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) +M:System.DBNull.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.DBNull.GetTypeCode +M:System.DBNull.ToString +M:System.DBNull.ToString(System.IFormatProvider) +M:System.Decimal.#ctor(System.Double) +M:System.Decimal.#ctor(System.Int32) +M:System.Decimal.#ctor(System.Int32,System.Int32,System.Int32,System.Boolean,System.Byte) +M:System.Decimal.#ctor(System.Int32[]) +M:System.Decimal.#ctor(System.Int64) +M:System.Decimal.#ctor(System.ReadOnlySpan{System.Int32}) +M:System.Decimal.#ctor(System.Single) +M:System.Decimal.#ctor(System.UInt32) +M:System.Decimal.#ctor(System.UInt64) +M:System.Decimal.Abs(System.Decimal) +M:System.Decimal.Add(System.Decimal,System.Decimal) +M:System.Decimal.Ceiling(System.Decimal) +M:System.Decimal.Clamp(System.Decimal,System.Decimal,System.Decimal) +M:System.Decimal.Compare(System.Decimal,System.Decimal) +M:System.Decimal.CompareTo(System.Decimal) +M:System.Decimal.CompareTo(System.Object) +M:System.Decimal.CopySign(System.Decimal,System.Decimal) +M:System.Decimal.CreateChecked``1(``0) +M:System.Decimal.CreateSaturating``1(``0) +M:System.Decimal.CreateTruncating``1(``0) +M:System.Decimal.Divide(System.Decimal,System.Decimal) +M:System.Decimal.Equals(System.Decimal) +M:System.Decimal.Equals(System.Decimal,System.Decimal) +M:System.Decimal.Equals(System.Object) +M:System.Decimal.Floor(System.Decimal) +M:System.Decimal.FromOACurrency(System.Int64) +M:System.Decimal.get_Scale +M:System.Decimal.GetBits(System.Decimal) +M:System.Decimal.GetBits(System.Decimal,System.Span{System.Int32}) +M:System.Decimal.GetHashCode +M:System.Decimal.GetTypeCode +M:System.Decimal.IsCanonical(System.Decimal) +M:System.Decimal.IsEvenInteger(System.Decimal) +M:System.Decimal.IsInteger(System.Decimal) +M:System.Decimal.IsNegative(System.Decimal) +M:System.Decimal.IsOddInteger(System.Decimal) +M:System.Decimal.IsPositive(System.Decimal) +M:System.Decimal.Max(System.Decimal,System.Decimal) +M:System.Decimal.MaxMagnitude(System.Decimal,System.Decimal) +M:System.Decimal.Min(System.Decimal,System.Decimal) +M:System.Decimal.MinMagnitude(System.Decimal,System.Decimal) +M:System.Decimal.Multiply(System.Decimal,System.Decimal) +M:System.Decimal.Negate(System.Decimal) +M:System.Decimal.op_Addition(System.Decimal,System.Decimal) +M:System.Decimal.op_Decrement(System.Decimal) +M:System.Decimal.op_Division(System.Decimal,System.Decimal) +M:System.Decimal.op_Equality(System.Decimal,System.Decimal) +M:System.Decimal.op_Explicit(System.Decimal)~System.Byte +M:System.Decimal.op_Explicit(System.Decimal)~System.Char +M:System.Decimal.op_Explicit(System.Decimal)~System.Double +M:System.Decimal.op_Explicit(System.Decimal)~System.Int16 +M:System.Decimal.op_Explicit(System.Decimal)~System.Int32 +M:System.Decimal.op_Explicit(System.Decimal)~System.Int64 +M:System.Decimal.op_Explicit(System.Decimal)~System.SByte +M:System.Decimal.op_Explicit(System.Decimal)~System.Single +M:System.Decimal.op_Explicit(System.Decimal)~System.UInt16 +M:System.Decimal.op_Explicit(System.Decimal)~System.UInt32 +M:System.Decimal.op_Explicit(System.Decimal)~System.UInt64 +M:System.Decimal.op_Explicit(System.Double)~System.Decimal +M:System.Decimal.op_Explicit(System.Single)~System.Decimal +M:System.Decimal.op_GreaterThan(System.Decimal,System.Decimal) +M:System.Decimal.op_GreaterThanOrEqual(System.Decimal,System.Decimal) +M:System.Decimal.op_Implicit(System.Byte)~System.Decimal +M:System.Decimal.op_Implicit(System.Char)~System.Decimal +M:System.Decimal.op_Implicit(System.Int16)~System.Decimal +M:System.Decimal.op_Implicit(System.Int32)~System.Decimal +M:System.Decimal.op_Implicit(System.Int64)~System.Decimal +M:System.Decimal.op_Implicit(System.SByte)~System.Decimal +M:System.Decimal.op_Implicit(System.UInt16)~System.Decimal +M:System.Decimal.op_Implicit(System.UInt32)~System.Decimal +M:System.Decimal.op_Implicit(System.UInt64)~System.Decimal +M:System.Decimal.op_Increment(System.Decimal) +M:System.Decimal.op_Inequality(System.Decimal,System.Decimal) +M:System.Decimal.op_LessThan(System.Decimal,System.Decimal) +M:System.Decimal.op_LessThanOrEqual(System.Decimal,System.Decimal) +M:System.Decimal.op_Modulus(System.Decimal,System.Decimal) +M:System.Decimal.op_Multiply(System.Decimal,System.Decimal) +M:System.Decimal.op_Subtraction(System.Decimal,System.Decimal) +M:System.Decimal.op_UnaryNegation(System.Decimal) +M:System.Decimal.op_UnaryPlus(System.Decimal) +M:System.Decimal.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Decimal.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Decimal.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Decimal.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Decimal.Parse(System.String) +M:System.Decimal.Parse(System.String,System.Globalization.NumberStyles) +M:System.Decimal.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Decimal.Parse(System.String,System.IFormatProvider) +M:System.Decimal.Remainder(System.Decimal,System.Decimal) +M:System.Decimal.Round(System.Decimal) +M:System.Decimal.Round(System.Decimal,System.Int32) +M:System.Decimal.Round(System.Decimal,System.Int32,System.MidpointRounding) +M:System.Decimal.Round(System.Decimal,System.MidpointRounding) +M:System.Decimal.Sign(System.Decimal) +M:System.Decimal.Subtract(System.Decimal,System.Decimal) +M:System.Decimal.ToByte(System.Decimal) +M:System.Decimal.ToDouble(System.Decimal) +M:System.Decimal.ToInt16(System.Decimal) +M:System.Decimal.ToInt32(System.Decimal) +M:System.Decimal.ToInt64(System.Decimal) +M:System.Decimal.ToOACurrency(System.Decimal) +M:System.Decimal.ToSByte(System.Decimal) +M:System.Decimal.ToSingle(System.Decimal) +M:System.Decimal.ToString +M:System.Decimal.ToString(System.IFormatProvider) +M:System.Decimal.ToString(System.String) +M:System.Decimal.ToString(System.String,System.IFormatProvider) +M:System.Decimal.ToUInt16(System.Decimal) +M:System.Decimal.ToUInt32(System.Decimal) +M:System.Decimal.ToUInt64(System.Decimal) +M:System.Decimal.Truncate(System.Decimal) +M:System.Decimal.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Decimal.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Decimal.TryGetBits(System.Decimal,System.Span{System.Int32},System.Int32@) +M:System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.Decimal@) +M:System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) +M:System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Decimal@) +M:System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.Decimal@) +M:System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) +M:System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Decimal@) +M:System.Decimal.TryParse(System.String,System.Decimal@) +M:System.Decimal.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) +M:System.Decimal.TryParse(System.String,System.IFormatProvider,System.Decimal@) +M:System.Delegate.#ctor(System.Object,System.String) +M:System.Delegate.#ctor(System.Type,System.String) +M:System.Delegate.Clone +M:System.Delegate.Combine(System.Delegate,System.Delegate) +M:System.Delegate.Combine(System.Delegate[]) +M:System.Delegate.CombineImpl(System.Delegate) +M:System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo) +M:System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boolean) +M:System.Delegate.CreateDelegate(System.Type,System.Object,System.String) +M:System.Delegate.CreateDelegate(System.Type,System.Object,System.String,System.Boolean) +M:System.Delegate.CreateDelegate(System.Type,System.Object,System.String,System.Boolean,System.Boolean) +M:System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo) +M:System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo,System.Boolean) +M:System.Delegate.CreateDelegate(System.Type,System.Type,System.String) +M:System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean) +M:System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean,System.Boolean) +M:System.Delegate.DynamicInvoke(System.Object[]) +M:System.Delegate.DynamicInvokeImpl(System.Object[]) +M:System.Delegate.Equals(System.Object) +M:System.Delegate.get_Method +M:System.Delegate.get_Target +M:System.Delegate.GetHashCode +M:System.Delegate.GetInvocationList +M:System.Delegate.GetMethodImpl +M:System.Delegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Delegate.op_Equality(System.Delegate,System.Delegate) +M:System.Delegate.op_Inequality(System.Delegate,System.Delegate) +M:System.Delegate.Remove(System.Delegate,System.Delegate) +M:System.Delegate.RemoveAll(System.Delegate,System.Delegate) +M:System.Delegate.RemoveImpl(System.Delegate) +M:System.Diagnostics.CodeAnalysis.AllowNullAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.get_Max +M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.get_Min +M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.set_Max(System.Object) +M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.set_Min(System.Object) +M:System.Diagnostics.CodeAnalysis.DisallowNullAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.#ctor(System.Boolean) +M:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.get_ParameterValue +M:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes) +M:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.get_MemberTypes +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,System.String,System.String) +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,System.Type) +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String,System.String,System.String) +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String,System.Type) +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_AssemblyName +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_Condition +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_MemberSignature +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_MemberTypes +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_Type +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_TypeName +M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.set_Condition(System.String) +M:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.get_Justification +M:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.set_Justification(System.String) +M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_DiagnosticId +M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_UrlFormat +M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.set_UrlFormat(System.String) +M:System.Diagnostics.CodeAnalysis.MaybeNullAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.#ctor(System.Boolean) +M:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.get_ReturnValue +M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String[]) +M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.get_Members +M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String) +M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String[]) +M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.get_Members +M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.get_ReturnValue +M:System.Diagnostics.CodeAnalysis.NotNullAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.get_ParameterName +M:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.#ctor(System.Boolean) +M:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.get_ReturnValue +M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.get_Message +M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.get_Url +M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.set_Url(System.String) +M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.get_Message +M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.get_Url +M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.set_Url(System.String) +M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.get_Message +M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.get_Url +M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.set_Url(System.String) +M:System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute.#ctor +M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.#ctor(System.String) +M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.#ctor(System.String,System.Object[]) +M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.get_Arguments +M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.get_Syntax +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.#ctor(System.String,System.String) +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Category +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_CheckId +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Justification +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_MessageId +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Scope +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Target +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Justification(System.String) +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_MessageId(System.String) +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Scope(System.String) +M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Target(System.String) +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.#ctor(System.String,System.String) +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Category +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_CheckId +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Justification +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_MessageId +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Scope +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Target +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Justification(System.String) +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_MessageId(System.String) +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Scope(System.String) +M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Target(System.String) +M:System.Diagnostics.CodeAnalysis.UnscopedRefAttribute.#ctor +M:System.Diagnostics.ConditionalAttribute.#ctor(System.String) +M:System.Diagnostics.ConditionalAttribute.get_ConditionString +M:System.Diagnostics.Debug.Assert(System.Boolean) +M:System.Diagnostics.Debug.Assert(System.Boolean,System.Diagnostics.Debug.AssertInterpolatedStringHandler@) +M:System.Diagnostics.Debug.Assert(System.Boolean,System.Diagnostics.Debug.AssertInterpolatedStringHandler@,System.Diagnostics.Debug.AssertInterpolatedStringHandler@) +M:System.Diagnostics.Debug.Assert(System.Boolean,System.String) +M:System.Diagnostics.Debug.Assert(System.Boolean,System.String,System.String) +M:System.Diagnostics.Debug.Assert(System.Boolean,System.String,System.String,System.Object[]) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Boolean,System.Boolean@) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.String) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendLiteral(System.String) +M:System.Diagnostics.Debug.Close +M:System.Diagnostics.Debug.Fail(System.String) +M:System.Diagnostics.Debug.Fail(System.String,System.String) +M:System.Diagnostics.Debug.Flush +M:System.Diagnostics.Debug.get_AutoFlush +M:System.Diagnostics.Debug.get_IndentLevel +M:System.Diagnostics.Debug.get_IndentSize +M:System.Diagnostics.Debug.Indent +M:System.Diagnostics.Debug.Print(System.String) +M:System.Diagnostics.Debug.Print(System.String,System.Object[]) +M:System.Diagnostics.Debug.set_AutoFlush(System.Boolean) +M:System.Diagnostics.Debug.set_IndentLevel(System.Int32) +M:System.Diagnostics.Debug.set_IndentSize(System.Int32) +M:System.Diagnostics.Debug.Unindent +M:System.Diagnostics.Debug.Write(System.Object) +M:System.Diagnostics.Debug.Write(System.Object,System.String) +M:System.Diagnostics.Debug.Write(System.String) +M:System.Diagnostics.Debug.Write(System.String,System.String) +M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@) +M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@,System.String) +M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Object) +M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Object,System.String) +M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.String) +M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.String,System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Boolean,System.Boolean@) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendLiteral(System.String) +M:System.Diagnostics.Debug.WriteLine(System.Object) +M:System.Diagnostics.Debug.WriteLine(System.Object,System.String) +M:System.Diagnostics.Debug.WriteLine(System.String) +M:System.Diagnostics.Debug.WriteLine(System.String,System.Object[]) +M:System.Diagnostics.Debug.WriteLine(System.String,System.String) +M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@) +M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@,System.String) +M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Object) +M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Object,System.String) +M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.String) +M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.String,System.String) +M:System.Diagnostics.DebuggableAttribute.#ctor(System.Boolean,System.Boolean) +M:System.Diagnostics.DebuggableAttribute.#ctor(System.Diagnostics.DebuggableAttribute.DebuggingModes) +M:System.Diagnostics.DebuggableAttribute.get_DebuggingFlags +M:System.Diagnostics.DebuggableAttribute.get_IsJITOptimizerDisabled +M:System.Diagnostics.DebuggableAttribute.get_IsJITTrackingEnabled +M:System.Diagnostics.DebuggerBrowsableAttribute.#ctor(System.Diagnostics.DebuggerBrowsableState) +M:System.Diagnostics.DebuggerBrowsableAttribute.get_State +M:System.Diagnostics.DebuggerDisplayAttribute.#ctor(System.String) +M:System.Diagnostics.DebuggerDisplayAttribute.get_Name +M:System.Diagnostics.DebuggerDisplayAttribute.get_Target +M:System.Diagnostics.DebuggerDisplayAttribute.get_TargetTypeName +M:System.Diagnostics.DebuggerDisplayAttribute.get_Type +M:System.Diagnostics.DebuggerDisplayAttribute.get_Value +M:System.Diagnostics.DebuggerDisplayAttribute.set_Name(System.String) +M:System.Diagnostics.DebuggerDisplayAttribute.set_Target(System.Type) +M:System.Diagnostics.DebuggerDisplayAttribute.set_TargetTypeName(System.String) +M:System.Diagnostics.DebuggerDisplayAttribute.set_Type(System.String) +M:System.Diagnostics.DebuggerHiddenAttribute.#ctor +M:System.Diagnostics.DebuggerNonUserCodeAttribute.#ctor +M:System.Diagnostics.DebuggerStepperBoundaryAttribute.#ctor +M:System.Diagnostics.DebuggerStepThroughAttribute.#ctor +M:System.Diagnostics.DebuggerTypeProxyAttribute.#ctor(System.String) +M:System.Diagnostics.DebuggerTypeProxyAttribute.#ctor(System.Type) +M:System.Diagnostics.DebuggerTypeProxyAttribute.get_ProxyTypeName +M:System.Diagnostics.DebuggerTypeProxyAttribute.get_Target +M:System.Diagnostics.DebuggerTypeProxyAttribute.get_TargetTypeName +M:System.Diagnostics.DebuggerTypeProxyAttribute.set_Target(System.Type) +M:System.Diagnostics.DebuggerTypeProxyAttribute.set_TargetTypeName(System.String) +M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String) +M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String,System.String) +M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String,System.Type) +M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type) +M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type,System.String) +M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type,System.Type) +M:System.Diagnostics.DebuggerVisualizerAttribute.get_Description +M:System.Diagnostics.DebuggerVisualizerAttribute.get_Target +M:System.Diagnostics.DebuggerVisualizerAttribute.get_TargetTypeName +M:System.Diagnostics.DebuggerVisualizerAttribute.get_VisualizerObjectSourceTypeName +M:System.Diagnostics.DebuggerVisualizerAttribute.get_VisualizerTypeName +M:System.Diagnostics.DebuggerVisualizerAttribute.set_Description(System.String) +M:System.Diagnostics.DebuggerVisualizerAttribute.set_Target(System.Type) +M:System.Diagnostics.DebuggerVisualizerAttribute.set_TargetTypeName(System.String) +M:System.Diagnostics.StackTraceHiddenAttribute.#ctor +M:System.Diagnostics.Stopwatch.#ctor +M:System.Diagnostics.Stopwatch.get_Elapsed +M:System.Diagnostics.Stopwatch.get_ElapsedMilliseconds +M:System.Diagnostics.Stopwatch.get_ElapsedTicks +M:System.Diagnostics.Stopwatch.get_IsRunning +M:System.Diagnostics.Stopwatch.GetElapsedTime(System.Int64) +M:System.Diagnostics.Stopwatch.GetElapsedTime(System.Int64,System.Int64) +M:System.Diagnostics.Stopwatch.GetTimestamp +M:System.Diagnostics.Stopwatch.Reset +M:System.Diagnostics.Stopwatch.Restart +M:System.Diagnostics.Stopwatch.Start +M:System.Diagnostics.Stopwatch.StartNew +M:System.Diagnostics.Stopwatch.Stop +M:System.Diagnostics.Stopwatch.ToString +M:System.Diagnostics.UnreachableException.#ctor +M:System.Diagnostics.UnreachableException.#ctor(System.String) +M:System.Diagnostics.UnreachableException.#ctor(System.String,System.Exception) +M:System.DivideByZeroException.#ctor +M:System.DivideByZeroException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.DivideByZeroException.#ctor(System.String) +M:System.DivideByZeroException.#ctor(System.String,System.Exception) +M:System.Double.Abs(System.Double) +M:System.Double.Acos(System.Double) +M:System.Double.Acosh(System.Double) +M:System.Double.AcosPi(System.Double) +M:System.Double.Asin(System.Double) +M:System.Double.Asinh(System.Double) +M:System.Double.AsinPi(System.Double) +M:System.Double.Atan(System.Double) +M:System.Double.Atan2(System.Double,System.Double) +M:System.Double.Atan2Pi(System.Double,System.Double) +M:System.Double.Atanh(System.Double) +M:System.Double.AtanPi(System.Double) +M:System.Double.BitDecrement(System.Double) +M:System.Double.BitIncrement(System.Double) +M:System.Double.Cbrt(System.Double) +M:System.Double.Ceiling(System.Double) +M:System.Double.Clamp(System.Double,System.Double,System.Double) +M:System.Double.CompareTo(System.Double) +M:System.Double.CompareTo(System.Object) +M:System.Double.CopySign(System.Double,System.Double) +M:System.Double.Cos(System.Double) +M:System.Double.Cosh(System.Double) +M:System.Double.CosPi(System.Double) +M:System.Double.CreateChecked``1(``0) +M:System.Double.CreateSaturating``1(``0) +M:System.Double.CreateTruncating``1(``0) +M:System.Double.DegreesToRadians(System.Double) +M:System.Double.Equals(System.Double) +M:System.Double.Equals(System.Object) +M:System.Double.Exp(System.Double) +M:System.Double.Exp10(System.Double) +M:System.Double.Exp10M1(System.Double) +M:System.Double.Exp2(System.Double) +M:System.Double.Exp2M1(System.Double) +M:System.Double.ExpM1(System.Double) +M:System.Double.Floor(System.Double) +M:System.Double.FusedMultiplyAdd(System.Double,System.Double,System.Double) +M:System.Double.GetHashCode +M:System.Double.GetTypeCode +M:System.Double.Hypot(System.Double,System.Double) +M:System.Double.Ieee754Remainder(System.Double,System.Double) +M:System.Double.ILogB(System.Double) +M:System.Double.IsEvenInteger(System.Double) +M:System.Double.IsFinite(System.Double) +M:System.Double.IsInfinity(System.Double) +M:System.Double.IsInteger(System.Double) +M:System.Double.IsNaN(System.Double) +M:System.Double.IsNegative(System.Double) +M:System.Double.IsNegativeInfinity(System.Double) +M:System.Double.IsNormal(System.Double) +M:System.Double.IsOddInteger(System.Double) +M:System.Double.IsPositive(System.Double) +M:System.Double.IsPositiveInfinity(System.Double) +M:System.Double.IsPow2(System.Double) +M:System.Double.IsRealNumber(System.Double) +M:System.Double.IsSubnormal(System.Double) +M:System.Double.Lerp(System.Double,System.Double,System.Double) +M:System.Double.Log(System.Double) +M:System.Double.Log(System.Double,System.Double) +M:System.Double.Log10(System.Double) +M:System.Double.Log10P1(System.Double) +M:System.Double.Log2(System.Double) +M:System.Double.Log2P1(System.Double) +M:System.Double.LogP1(System.Double) +M:System.Double.Max(System.Double,System.Double) +M:System.Double.MaxMagnitude(System.Double,System.Double) +M:System.Double.MaxMagnitudeNumber(System.Double,System.Double) +M:System.Double.MaxNumber(System.Double,System.Double) +M:System.Double.Min(System.Double,System.Double) +M:System.Double.MinMagnitude(System.Double,System.Double) +M:System.Double.MinMagnitudeNumber(System.Double,System.Double) +M:System.Double.MinNumber(System.Double,System.Double) +M:System.Double.op_Equality(System.Double,System.Double) +M:System.Double.op_GreaterThan(System.Double,System.Double) +M:System.Double.op_GreaterThanOrEqual(System.Double,System.Double) +M:System.Double.op_Inequality(System.Double,System.Double) +M:System.Double.op_LessThan(System.Double,System.Double) +M:System.Double.op_LessThanOrEqual(System.Double,System.Double) +M:System.Double.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Double.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Double.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Double.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Double.Parse(System.String) +M:System.Double.Parse(System.String,System.Globalization.NumberStyles) +M:System.Double.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Double.Parse(System.String,System.IFormatProvider) +M:System.Double.Pow(System.Double,System.Double) +M:System.Double.RadiansToDegrees(System.Double) +M:System.Double.ReciprocalEstimate(System.Double) +M:System.Double.ReciprocalSqrtEstimate(System.Double) +M:System.Double.RootN(System.Double,System.Int32) +M:System.Double.Round(System.Double) +M:System.Double.Round(System.Double,System.Int32) +M:System.Double.Round(System.Double,System.Int32,System.MidpointRounding) +M:System.Double.Round(System.Double,System.MidpointRounding) +M:System.Double.ScaleB(System.Double,System.Int32) +M:System.Double.Sign(System.Double) +M:System.Double.Sin(System.Double) +M:System.Double.SinCos(System.Double) +M:System.Double.SinCosPi(System.Double) +M:System.Double.Sinh(System.Double) +M:System.Double.SinPi(System.Double) +M:System.Double.Sqrt(System.Double) +M:System.Double.Tan(System.Double) +M:System.Double.Tanh(System.Double) +M:System.Double.TanPi(System.Double) +M:System.Double.ToString +M:System.Double.ToString(System.IFormatProvider) +M:System.Double.ToString(System.String) +M:System.Double.ToString(System.String,System.IFormatProvider) +M:System.Double.Truncate(System.Double) +M:System.Double.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Double.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.Double@) +M:System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) +M:System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Double@) +M:System.Double.TryParse(System.ReadOnlySpan{System.Char},System.Double@) +M:System.Double.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) +M:System.Double.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Double@) +M:System.Double.TryParse(System.String,System.Double@) +M:System.Double.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) +M:System.Double.TryParse(System.String,System.IFormatProvider,System.Double@) +M:System.DuplicateWaitObjectException.#ctor +M:System.DuplicateWaitObjectException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.DuplicateWaitObjectException.#ctor(System.String) +M:System.DuplicateWaitObjectException.#ctor(System.String,System.Exception) +M:System.DuplicateWaitObjectException.#ctor(System.String,System.String) +M:System.EntryPointNotFoundException.#ctor +M:System.EntryPointNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.EntryPointNotFoundException.#ctor(System.String) +M:System.EntryPointNotFoundException.#ctor(System.String,System.Exception) +M:System.Enum.#ctor +M:System.Enum.CompareTo(System.Object) +M:System.Enum.Equals(System.Object) +M:System.Enum.Format(System.Type,System.Object,System.String) +M:System.Enum.GetHashCode +M:System.Enum.GetName(System.Type,System.Object) +M:System.Enum.GetName``1(``0) +M:System.Enum.GetNames(System.Type) +M:System.Enum.GetNames``1 +M:System.Enum.GetTypeCode +M:System.Enum.GetUnderlyingType(System.Type) +M:System.Enum.GetValues(System.Type) +M:System.Enum.GetValues``1 +M:System.Enum.GetValuesAsUnderlyingType(System.Type) +M:System.Enum.GetValuesAsUnderlyingType``1 +M:System.Enum.HasFlag(System.Enum) +M:System.Enum.IsDefined(System.Type,System.Object) +M:System.Enum.IsDefined``1(``0) +M:System.Enum.Parse(System.Type,System.ReadOnlySpan{System.Char}) +M:System.Enum.Parse(System.Type,System.ReadOnlySpan{System.Char},System.Boolean) +M:System.Enum.Parse(System.Type,System.String) +M:System.Enum.Parse(System.Type,System.String,System.Boolean) +M:System.Enum.Parse``1(System.ReadOnlySpan{System.Char}) +M:System.Enum.Parse``1(System.ReadOnlySpan{System.Char},System.Boolean) +M:System.Enum.Parse``1(System.String) +M:System.Enum.Parse``1(System.String,System.Boolean) +M:System.Enum.ToObject(System.Type,System.Byte) +M:System.Enum.ToObject(System.Type,System.Int16) +M:System.Enum.ToObject(System.Type,System.Int32) +M:System.Enum.ToObject(System.Type,System.Int64) +M:System.Enum.ToObject(System.Type,System.Object) +M:System.Enum.ToObject(System.Type,System.SByte) +M:System.Enum.ToObject(System.Type,System.UInt16) +M:System.Enum.ToObject(System.Type,System.UInt32) +M:System.Enum.ToObject(System.Type,System.UInt64) +M:System.Enum.ToString +M:System.Enum.ToString(System.IFormatProvider) +M:System.Enum.ToString(System.String) +M:System.Enum.ToString(System.String,System.IFormatProvider) +M:System.Enum.TryFormat``1(``0,System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char}) +M:System.Enum.TryParse(System.Type,System.ReadOnlySpan{System.Char},System.Boolean,System.Object@) +M:System.Enum.TryParse(System.Type,System.ReadOnlySpan{System.Char},System.Object@) +M:System.Enum.TryParse(System.Type,System.String,System.Boolean,System.Object@) +M:System.Enum.TryParse(System.Type,System.String,System.Object@) +M:System.Enum.TryParse``1(System.ReadOnlySpan{System.Char},``0@) +M:System.Enum.TryParse``1(System.ReadOnlySpan{System.Char},System.Boolean,``0@) +M:System.Enum.TryParse``1(System.String,``0@) +M:System.Enum.TryParse``1(System.String,System.Boolean,``0@) +M:System.Environment.get_CurrentManagedThreadId +M:System.Environment.get_NewLine +M:System.EventArgs.#ctor +M:System.EventHandler.#ctor(System.Object,System.IntPtr) +M:System.EventHandler.BeginInvoke(System.Object,System.EventArgs,System.AsyncCallback,System.Object) +M:System.EventHandler.EndInvoke(System.IAsyncResult) +M:System.EventHandler.Invoke(System.Object,System.EventArgs) +M:System.EventHandler`1.#ctor(System.Object,System.IntPtr) +M:System.EventHandler`1.BeginInvoke(System.Object,`0,System.AsyncCallback,System.Object) +M:System.EventHandler`1.EndInvoke(System.IAsyncResult) +M:System.EventHandler`1.Invoke(System.Object,`0) +M:System.Exception.#ctor +M:System.Exception.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Exception.#ctor(System.String) +M:System.Exception.#ctor(System.String,System.Exception) +M:System.Exception.add_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs}) +M:System.Exception.get_Data +M:System.Exception.get_HelpLink +M:System.Exception.get_HResult +M:System.Exception.get_InnerException +M:System.Exception.get_Message +M:System.Exception.get_Source +M:System.Exception.get_StackTrace +M:System.Exception.get_TargetSite +M:System.Exception.GetBaseException +M:System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Exception.GetType +M:System.Exception.remove_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs}) +M:System.Exception.set_HelpLink(System.String) +M:System.Exception.set_HResult(System.Int32) +M:System.Exception.set_Source(System.String) +M:System.Exception.ToString +M:System.ExecutionEngineException.#ctor +M:System.ExecutionEngineException.#ctor(System.String) +M:System.ExecutionEngineException.#ctor(System.String,System.Exception) +M:System.FieldAccessException.#ctor +M:System.FieldAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.FieldAccessException.#ctor(System.String) +M:System.FieldAccessException.#ctor(System.String,System.Exception) +M:System.FileStyleUriParser.#ctor +M:System.FlagsAttribute.#ctor +M:System.FormatException.#ctor +M:System.FormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.FormatException.#ctor(System.String) +M:System.FormatException.#ctor(System.String,System.Exception) +M:System.FormattableString.#ctor +M:System.FormattableString.CurrentCulture(System.FormattableString) +M:System.FormattableString.get_ArgumentCount +M:System.FormattableString.get_Format +M:System.FormattableString.GetArgument(System.Int32) +M:System.FormattableString.GetArguments +M:System.FormattableString.Invariant(System.FormattableString) +M:System.FormattableString.ToString +M:System.FormattableString.ToString(System.IFormatProvider) +M:System.FtpStyleUriParser.#ctor +M:System.Func`1.#ctor(System.Object,System.IntPtr) +M:System.Func`1.BeginInvoke(System.AsyncCallback,System.Object) +M:System.Func`1.EndInvoke(System.IAsyncResult) +M:System.Func`1.Invoke +M:System.Func`10.#ctor(System.Object,System.IntPtr) +M:System.Func`10.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,System.AsyncCallback,System.Object) +M:System.Func`10.EndInvoke(System.IAsyncResult) +M:System.Func`10.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8) +M:System.Func`11.#ctor(System.Object,System.IntPtr) +M:System.Func`11.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,System.AsyncCallback,System.Object) +M:System.Func`11.EndInvoke(System.IAsyncResult) +M:System.Func`11.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9) +M:System.Func`12.#ctor(System.Object,System.IntPtr) +M:System.Func`12.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,System.AsyncCallback,System.Object) +M:System.Func`12.EndInvoke(System.IAsyncResult) +M:System.Func`12.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10) +M:System.Func`13.#ctor(System.Object,System.IntPtr) +M:System.Func`13.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,System.AsyncCallback,System.Object) +M:System.Func`13.EndInvoke(System.IAsyncResult) +M:System.Func`13.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11) +M:System.Func`14.#ctor(System.Object,System.IntPtr) +M:System.Func`14.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,System.AsyncCallback,System.Object) +M:System.Func`14.EndInvoke(System.IAsyncResult) +M:System.Func`14.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12) +M:System.Func`15.#ctor(System.Object,System.IntPtr) +M:System.Func`15.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,System.AsyncCallback,System.Object) +M:System.Func`15.EndInvoke(System.IAsyncResult) +M:System.Func`15.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13) +M:System.Func`16.#ctor(System.Object,System.IntPtr) +M:System.Func`16.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,System.AsyncCallback,System.Object) +M:System.Func`16.EndInvoke(System.IAsyncResult) +M:System.Func`16.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14) +M:System.Func`17.#ctor(System.Object,System.IntPtr) +M:System.Func`17.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15,System.AsyncCallback,System.Object) +M:System.Func`17.EndInvoke(System.IAsyncResult) +M:System.Func`17.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15) +M:System.Func`2.#ctor(System.Object,System.IntPtr) +M:System.Func`2.BeginInvoke(`0,System.AsyncCallback,System.Object) +M:System.Func`2.EndInvoke(System.IAsyncResult) +M:System.Func`2.Invoke(`0) +M:System.Func`3.#ctor(System.Object,System.IntPtr) +M:System.Func`3.BeginInvoke(`0,`1,System.AsyncCallback,System.Object) +M:System.Func`3.EndInvoke(System.IAsyncResult) +M:System.Func`3.Invoke(`0,`1) +M:System.Func`4.#ctor(System.Object,System.IntPtr) +M:System.Func`4.BeginInvoke(`0,`1,`2,System.AsyncCallback,System.Object) +M:System.Func`4.EndInvoke(System.IAsyncResult) +M:System.Func`4.Invoke(`0,`1,`2) +M:System.Func`5.#ctor(System.Object,System.IntPtr) +M:System.Func`5.BeginInvoke(`0,`1,`2,`3,System.AsyncCallback,System.Object) +M:System.Func`5.EndInvoke(System.IAsyncResult) +M:System.Func`5.Invoke(`0,`1,`2,`3) +M:System.Func`6.#ctor(System.Object,System.IntPtr) +M:System.Func`6.BeginInvoke(`0,`1,`2,`3,`4,System.AsyncCallback,System.Object) +M:System.Func`6.EndInvoke(System.IAsyncResult) +M:System.Func`6.Invoke(`0,`1,`2,`3,`4) +M:System.Func`7.#ctor(System.Object,System.IntPtr) +M:System.Func`7.BeginInvoke(`0,`1,`2,`3,`4,`5,System.AsyncCallback,System.Object) +M:System.Func`7.EndInvoke(System.IAsyncResult) +M:System.Func`7.Invoke(`0,`1,`2,`3,`4,`5) +M:System.Func`8.#ctor(System.Object,System.IntPtr) +M:System.Func`8.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,System.AsyncCallback,System.Object) +M:System.Func`8.EndInvoke(System.IAsyncResult) +M:System.Func`8.Invoke(`0,`1,`2,`3,`4,`5,`6) +M:System.Func`9.#ctor(System.Object,System.IntPtr) +M:System.Func`9.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,System.AsyncCallback,System.Object) +M:System.Func`9.EndInvoke(System.IAsyncResult) +M:System.Func`9.Invoke(`0,`1,`2,`3,`4,`5,`6,`7) +M:System.GenericUriParser.#ctor(System.GenericUriParserOptions) +M:System.Globalization.Calendar.#ctor +M:System.Globalization.Calendar.AddDays(System.DateTime,System.Int32) +M:System.Globalization.Calendar.AddHours(System.DateTime,System.Int32) +M:System.Globalization.Calendar.AddMilliseconds(System.DateTime,System.Double) +M:System.Globalization.Calendar.AddMinutes(System.DateTime,System.Int32) +M:System.Globalization.Calendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.Calendar.AddSeconds(System.DateTime,System.Int32) +M:System.Globalization.Calendar.AddWeeks(System.DateTime,System.Int32) +M:System.Globalization.Calendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.Calendar.Clone +M:System.Globalization.Calendar.get_AlgorithmType +M:System.Globalization.Calendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.Calendar.get_Eras +M:System.Globalization.Calendar.get_IsReadOnly +M:System.Globalization.Calendar.get_MaxSupportedDateTime +M:System.Globalization.Calendar.get_MinSupportedDateTime +M:System.Globalization.Calendar.get_TwoDigitYearMax +M:System.Globalization.Calendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.Calendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.Calendar.GetDayOfYear(System.DateTime) +M:System.Globalization.Calendar.GetDaysInMonth(System.Int32,System.Int32) +M:System.Globalization.Calendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.Calendar.GetDaysInYear(System.Int32) +M:System.Globalization.Calendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.Calendar.GetEra(System.DateTime) +M:System.Globalization.Calendar.GetHour(System.DateTime) +M:System.Globalization.Calendar.GetLeapMonth(System.Int32) +M:System.Globalization.Calendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.Calendar.GetMilliseconds(System.DateTime) +M:System.Globalization.Calendar.GetMinute(System.DateTime) +M:System.Globalization.Calendar.GetMonth(System.DateTime) +M:System.Globalization.Calendar.GetMonthsInYear(System.Int32) +M:System.Globalization.Calendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.Calendar.GetSecond(System.DateTime) +M:System.Globalization.Calendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +M:System.Globalization.Calendar.GetYear(System.DateTime) +M:System.Globalization.Calendar.IsLeapDay(System.Int32,System.Int32,System.Int32) +M:System.Globalization.Calendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.Calendar.IsLeapMonth(System.Int32,System.Int32) +M:System.Globalization.Calendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.Calendar.IsLeapYear(System.Int32) +M:System.Globalization.Calendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.Calendar.ReadOnly(System.Globalization.Calendar) +M:System.Globalization.Calendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.Calendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.Calendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.Calendar.ToFourDigitYear(System.Int32) +M:System.Globalization.CharUnicodeInfo.GetDecimalDigitValue(System.Char) +M:System.Globalization.CharUnicodeInfo.GetDecimalDigitValue(System.String,System.Int32) +M:System.Globalization.CharUnicodeInfo.GetDigitValue(System.Char) +M:System.Globalization.CharUnicodeInfo.GetDigitValue(System.String,System.Int32) +M:System.Globalization.CharUnicodeInfo.GetNumericValue(System.Char) +M:System.Globalization.CharUnicodeInfo.GetNumericValue(System.String,System.Int32) +M:System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Char) +M:System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Int32) +M:System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.String,System.Int32) +M:System.Globalization.ChineseLunisolarCalendar.#ctor +M:System.Globalization.ChineseLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.ChineseLunisolarCalendar.get_Eras +M:System.Globalization.ChineseLunisolarCalendar.get_MaxSupportedDateTime +M:System.Globalization.ChineseLunisolarCalendar.get_MinSupportedDateTime +M:System.Globalization.ChineseLunisolarCalendar.GetEra(System.DateTime) +M:System.Globalization.CompareInfo.Compare(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32) +M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.String,System.Int32) +M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.String,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.Compare(System.String,System.String) +M:System.Globalization.CompareInfo.Compare(System.String,System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.Equals(System.Object) +M:System.Globalization.CompareInfo.get_LCID +M:System.Globalization.CompareInfo.get_Name +M:System.Globalization.CompareInfo.get_Version +M:System.Globalization.CompareInfo.GetCompareInfo(System.Int32) +M:System.Globalization.CompareInfo.GetCompareInfo(System.Int32,System.Reflection.Assembly) +M:System.Globalization.CompareInfo.GetCompareInfo(System.String) +M:System.Globalization.CompareInfo.GetCompareInfo(System.String,System.Reflection.Assembly) +M:System.Globalization.CompareInfo.GetHashCode +M:System.Globalization.CompareInfo.GetHashCode(System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.GetHashCode(System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.GetSortKey(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.GetSortKey(System.String) +M:System.Globalization.CompareInfo.GetSortKey(System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.GetSortKeyLength(System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +M:System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.Text.Rune,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Int32) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.String) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Int32) +M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IsPrefix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IsPrefix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +M:System.Globalization.CompareInfo.IsPrefix(System.String,System.String) +M:System.Globalization.CompareInfo.IsPrefix(System.String,System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IsSortable(System.Char) +M:System.Globalization.CompareInfo.IsSortable(System.ReadOnlySpan{System.Char}) +M:System.Globalization.CompareInfo.IsSortable(System.String) +M:System.Globalization.CompareInfo.IsSortable(System.Text.Rune) +M:System.Globalization.CompareInfo.IsSuffix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.IsSuffix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +M:System.Globalization.CompareInfo.IsSuffix(System.String,System.String) +M:System.Globalization.CompareInfo.IsSuffix(System.String,System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) +M:System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.Text.Rune,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Int32) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Int32) +M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) +M:System.Globalization.CompareInfo.ToString +M:System.Globalization.CultureInfo.#ctor(System.Int32) +M:System.Globalization.CultureInfo.#ctor(System.Int32,System.Boolean) +M:System.Globalization.CultureInfo.#ctor(System.String) +M:System.Globalization.CultureInfo.#ctor(System.String,System.Boolean) +M:System.Globalization.CultureInfo.ClearCachedData +M:System.Globalization.CultureInfo.Clone +M:System.Globalization.CultureInfo.CreateSpecificCulture(System.String) +M:System.Globalization.CultureInfo.Equals(System.Object) +M:System.Globalization.CultureInfo.get_Calendar +M:System.Globalization.CultureInfo.get_CompareInfo +M:System.Globalization.CultureInfo.get_CultureTypes +M:System.Globalization.CultureInfo.get_CurrentCulture +M:System.Globalization.CultureInfo.get_CurrentUICulture +M:System.Globalization.CultureInfo.get_DateTimeFormat +M:System.Globalization.CultureInfo.get_DefaultThreadCurrentCulture +M:System.Globalization.CultureInfo.get_DefaultThreadCurrentUICulture +M:System.Globalization.CultureInfo.get_DisplayName +M:System.Globalization.CultureInfo.get_EnglishName +M:System.Globalization.CultureInfo.get_IetfLanguageTag +M:System.Globalization.CultureInfo.get_InstalledUICulture +M:System.Globalization.CultureInfo.get_InvariantCulture +M:System.Globalization.CultureInfo.get_IsNeutralCulture +M:System.Globalization.CultureInfo.get_IsReadOnly +M:System.Globalization.CultureInfo.get_KeyboardLayoutId +M:System.Globalization.CultureInfo.get_LCID +M:System.Globalization.CultureInfo.get_Name +M:System.Globalization.CultureInfo.get_NativeName +M:System.Globalization.CultureInfo.get_NumberFormat +M:System.Globalization.CultureInfo.get_OptionalCalendars +M:System.Globalization.CultureInfo.get_Parent +M:System.Globalization.CultureInfo.get_TextInfo +M:System.Globalization.CultureInfo.get_ThreeLetterISOLanguageName +M:System.Globalization.CultureInfo.get_ThreeLetterWindowsLanguageName +M:System.Globalization.CultureInfo.get_TwoLetterISOLanguageName +M:System.Globalization.CultureInfo.get_UseUserOverride +M:System.Globalization.CultureInfo.GetConsoleFallbackUICulture +M:System.Globalization.CultureInfo.GetCultureInfo(System.Int32) +M:System.Globalization.CultureInfo.GetCultureInfo(System.String) +M:System.Globalization.CultureInfo.GetCultureInfo(System.String,System.Boolean) +M:System.Globalization.CultureInfo.GetCultureInfo(System.String,System.String) +M:System.Globalization.CultureInfo.GetCultureInfoByIetfLanguageTag(System.String) +M:System.Globalization.CultureInfo.GetCultures(System.Globalization.CultureTypes) +M:System.Globalization.CultureInfo.GetFormat(System.Type) +M:System.Globalization.CultureInfo.GetHashCode +M:System.Globalization.CultureInfo.ReadOnly(System.Globalization.CultureInfo) +M:System.Globalization.CultureInfo.ToString +M:System.Globalization.CultureNotFoundException.#ctor +M:System.Globalization.CultureNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Globalization.CultureNotFoundException.#ctor(System.String) +M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.Exception) +M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.Int32,System.Exception) +M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.Int32,System.String) +M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.String) +M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.String,System.Exception) +M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.String,System.String) +M:System.Globalization.CultureNotFoundException.get_InvalidCultureId +M:System.Globalization.CultureNotFoundException.get_InvalidCultureName +M:System.Globalization.CultureNotFoundException.get_Message +M:System.Globalization.CultureNotFoundException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Globalization.DateTimeFormatInfo.#ctor +M:System.Globalization.DateTimeFormatInfo.Clone +M:System.Globalization.DateTimeFormatInfo.get_AbbreviatedDayNames +M:System.Globalization.DateTimeFormatInfo.get_AbbreviatedMonthGenitiveNames +M:System.Globalization.DateTimeFormatInfo.get_AbbreviatedMonthNames +M:System.Globalization.DateTimeFormatInfo.get_AMDesignator +M:System.Globalization.DateTimeFormatInfo.get_Calendar +M:System.Globalization.DateTimeFormatInfo.get_CalendarWeekRule +M:System.Globalization.DateTimeFormatInfo.get_CurrentInfo +M:System.Globalization.DateTimeFormatInfo.get_DateSeparator +M:System.Globalization.DateTimeFormatInfo.get_DayNames +M:System.Globalization.DateTimeFormatInfo.get_FirstDayOfWeek +M:System.Globalization.DateTimeFormatInfo.get_FullDateTimePattern +M:System.Globalization.DateTimeFormatInfo.get_InvariantInfo +M:System.Globalization.DateTimeFormatInfo.get_IsReadOnly +M:System.Globalization.DateTimeFormatInfo.get_LongDatePattern +M:System.Globalization.DateTimeFormatInfo.get_LongTimePattern +M:System.Globalization.DateTimeFormatInfo.get_MonthDayPattern +M:System.Globalization.DateTimeFormatInfo.get_MonthGenitiveNames +M:System.Globalization.DateTimeFormatInfo.get_MonthNames +M:System.Globalization.DateTimeFormatInfo.get_NativeCalendarName +M:System.Globalization.DateTimeFormatInfo.get_PMDesignator +M:System.Globalization.DateTimeFormatInfo.get_RFC1123Pattern +M:System.Globalization.DateTimeFormatInfo.get_ShortDatePattern +M:System.Globalization.DateTimeFormatInfo.get_ShortestDayNames +M:System.Globalization.DateTimeFormatInfo.get_ShortTimePattern +M:System.Globalization.DateTimeFormatInfo.get_SortableDateTimePattern +M:System.Globalization.DateTimeFormatInfo.get_TimeSeparator +M:System.Globalization.DateTimeFormatInfo.get_UniversalSortableDateTimePattern +M:System.Globalization.DateTimeFormatInfo.get_YearMonthPattern +M:System.Globalization.DateTimeFormatInfo.GetAbbreviatedDayName(System.DayOfWeek) +M:System.Globalization.DateTimeFormatInfo.GetAbbreviatedEraName(System.Int32) +M:System.Globalization.DateTimeFormatInfo.GetAbbreviatedMonthName(System.Int32) +M:System.Globalization.DateTimeFormatInfo.GetAllDateTimePatterns +M:System.Globalization.DateTimeFormatInfo.GetAllDateTimePatterns(System.Char) +M:System.Globalization.DateTimeFormatInfo.GetDayName(System.DayOfWeek) +M:System.Globalization.DateTimeFormatInfo.GetEra(System.String) +M:System.Globalization.DateTimeFormatInfo.GetEraName(System.Int32) +M:System.Globalization.DateTimeFormatInfo.GetFormat(System.Type) +M:System.Globalization.DateTimeFormatInfo.GetInstance(System.IFormatProvider) +M:System.Globalization.DateTimeFormatInfo.GetMonthName(System.Int32) +M:System.Globalization.DateTimeFormatInfo.GetShortestDayName(System.DayOfWeek) +M:System.Globalization.DateTimeFormatInfo.ReadOnly(System.Globalization.DateTimeFormatInfo) +M:System.Globalization.DateTimeFormatInfo.set_AbbreviatedDayNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_AbbreviatedMonthGenitiveNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_AbbreviatedMonthNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_AMDesignator(System.String) +M:System.Globalization.DateTimeFormatInfo.set_Calendar(System.Globalization.Calendar) +M:System.Globalization.DateTimeFormatInfo.set_CalendarWeekRule(System.Globalization.CalendarWeekRule) +M:System.Globalization.DateTimeFormatInfo.set_DateSeparator(System.String) +M:System.Globalization.DateTimeFormatInfo.set_DayNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_FirstDayOfWeek(System.DayOfWeek) +M:System.Globalization.DateTimeFormatInfo.set_FullDateTimePattern(System.String) +M:System.Globalization.DateTimeFormatInfo.set_LongDatePattern(System.String) +M:System.Globalization.DateTimeFormatInfo.set_LongTimePattern(System.String) +M:System.Globalization.DateTimeFormatInfo.set_MonthDayPattern(System.String) +M:System.Globalization.DateTimeFormatInfo.set_MonthGenitiveNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_MonthNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_PMDesignator(System.String) +M:System.Globalization.DateTimeFormatInfo.set_ShortDatePattern(System.String) +M:System.Globalization.DateTimeFormatInfo.set_ShortestDayNames(System.String[]) +M:System.Globalization.DateTimeFormatInfo.set_ShortTimePattern(System.String) +M:System.Globalization.DateTimeFormatInfo.set_TimeSeparator(System.String) +M:System.Globalization.DateTimeFormatInfo.set_YearMonthPattern(System.String) +M:System.Globalization.DateTimeFormatInfo.SetAllDateTimePatterns(System.String[],System.Char) +M:System.Globalization.DaylightTime.#ctor(System.DateTime,System.DateTime,System.TimeSpan) +M:System.Globalization.DaylightTime.get_Delta +M:System.Globalization.DaylightTime.get_End +M:System.Globalization.DaylightTime.get_Start +M:System.Globalization.EastAsianLunisolarCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.get_AlgorithmType +M:System.Globalization.EastAsianLunisolarCalendar.get_TwoDigitYearMax +M:System.Globalization.EastAsianLunisolarCalendar.GetCelestialStem(System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.EastAsianLunisolarCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.EastAsianLunisolarCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.EastAsianLunisolarCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.GetMonth(System.DateTime) +M:System.Globalization.EastAsianLunisolarCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.GetSexagenaryYear(System.DateTime) +M:System.Globalization.EastAsianLunisolarCalendar.GetTerrestrialBranch(System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.GetYear(System.DateTime) +M:System.Globalization.EastAsianLunisolarCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.EastAsianLunisolarCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.GlobalizationExtensions.GetStringComparer(System.Globalization.CompareInfo,System.Globalization.CompareOptions) +M:System.Globalization.GregorianCalendar.#ctor +M:System.Globalization.GregorianCalendar.#ctor(System.Globalization.GregorianCalendarTypes) +M:System.Globalization.GregorianCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.GregorianCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.GregorianCalendar.get_AlgorithmType +M:System.Globalization.GregorianCalendar.get_CalendarType +M:System.Globalization.GregorianCalendar.get_Eras +M:System.Globalization.GregorianCalendar.get_MaxSupportedDateTime +M:System.Globalization.GregorianCalendar.get_MinSupportedDateTime +M:System.Globalization.GregorianCalendar.get_TwoDigitYearMax +M:System.Globalization.GregorianCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.GregorianCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.GregorianCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.GregorianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.GetEra(System.DateTime) +M:System.Globalization.GregorianCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.GetMonth(System.DateTime) +M:System.Globalization.GregorianCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.GetYear(System.DateTime) +M:System.Globalization.GregorianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.set_CalendarType(System.Globalization.GregorianCalendarTypes) +M:System.Globalization.GregorianCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.GregorianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.GregorianCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.HebrewCalendar.#ctor +M:System.Globalization.HebrewCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.HebrewCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.HebrewCalendar.get_AlgorithmType +M:System.Globalization.HebrewCalendar.get_Eras +M:System.Globalization.HebrewCalendar.get_MaxSupportedDateTime +M:System.Globalization.HebrewCalendar.get_MinSupportedDateTime +M:System.Globalization.HebrewCalendar.get_TwoDigitYearMax +M:System.Globalization.HebrewCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.HebrewCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.HebrewCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.HebrewCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.GetEra(System.DateTime) +M:System.Globalization.HebrewCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.GetMonth(System.DateTime) +M:System.Globalization.HebrewCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.GetYear(System.DateTime) +M:System.Globalization.HebrewCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.HebrewCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.HebrewCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.HijriCalendar.#ctor +M:System.Globalization.HijriCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.HijriCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.HijriCalendar.get_AlgorithmType +M:System.Globalization.HijriCalendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.HijriCalendar.get_Eras +M:System.Globalization.HijriCalendar.get_HijriAdjustment +M:System.Globalization.HijriCalendar.get_MaxSupportedDateTime +M:System.Globalization.HijriCalendar.get_MinSupportedDateTime +M:System.Globalization.HijriCalendar.get_TwoDigitYearMax +M:System.Globalization.HijriCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.HijriCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.HijriCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.HijriCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.GetEra(System.DateTime) +M:System.Globalization.HijriCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.GetMonth(System.DateTime) +M:System.Globalization.HijriCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.GetYear(System.DateTime) +M:System.Globalization.HijriCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.set_HijriAdjustment(System.Int32) +M:System.Globalization.HijriCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.HijriCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.HijriCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.IdnMapping.#ctor +M:System.Globalization.IdnMapping.Equals(System.Object) +M:System.Globalization.IdnMapping.get_AllowUnassigned +M:System.Globalization.IdnMapping.get_UseStd3AsciiRules +M:System.Globalization.IdnMapping.GetAscii(System.String) +M:System.Globalization.IdnMapping.GetAscii(System.String,System.Int32) +M:System.Globalization.IdnMapping.GetAscii(System.String,System.Int32,System.Int32) +M:System.Globalization.IdnMapping.GetHashCode +M:System.Globalization.IdnMapping.GetUnicode(System.String) +M:System.Globalization.IdnMapping.GetUnicode(System.String,System.Int32) +M:System.Globalization.IdnMapping.GetUnicode(System.String,System.Int32,System.Int32) +M:System.Globalization.IdnMapping.set_AllowUnassigned(System.Boolean) +M:System.Globalization.IdnMapping.set_UseStd3AsciiRules(System.Boolean) +M:System.Globalization.ISOWeek.GetWeekOfYear(System.DateTime) +M:System.Globalization.ISOWeek.GetWeeksInYear(System.Int32) +M:System.Globalization.ISOWeek.GetYear(System.DateTime) +M:System.Globalization.ISOWeek.GetYearEnd(System.Int32) +M:System.Globalization.ISOWeek.GetYearStart(System.Int32) +M:System.Globalization.ISOWeek.ToDateTime(System.Int32,System.Int32,System.DayOfWeek) +M:System.Globalization.JapaneseCalendar.#ctor +M:System.Globalization.JapaneseCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.JapaneseCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.JapaneseCalendar.get_AlgorithmType +M:System.Globalization.JapaneseCalendar.get_Eras +M:System.Globalization.JapaneseCalendar.get_MaxSupportedDateTime +M:System.Globalization.JapaneseCalendar.get_MinSupportedDateTime +M:System.Globalization.JapaneseCalendar.get_TwoDigitYearMax +M:System.Globalization.JapaneseCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.JapaneseCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.JapaneseCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.JapaneseCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.GetEra(System.DateTime) +M:System.Globalization.JapaneseCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.GetMonth(System.DateTime) +M:System.Globalization.JapaneseCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +M:System.Globalization.JapaneseCalendar.GetYear(System.DateTime) +M:System.Globalization.JapaneseCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.JapaneseCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.JapaneseCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.JapaneseLunisolarCalendar.#ctor +M:System.Globalization.JapaneseLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.JapaneseLunisolarCalendar.get_Eras +M:System.Globalization.JapaneseLunisolarCalendar.get_MaxSupportedDateTime +M:System.Globalization.JapaneseLunisolarCalendar.get_MinSupportedDateTime +M:System.Globalization.JapaneseLunisolarCalendar.GetEra(System.DateTime) +M:System.Globalization.JulianCalendar.#ctor +M:System.Globalization.JulianCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.JulianCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.JulianCalendar.get_AlgorithmType +M:System.Globalization.JulianCalendar.get_Eras +M:System.Globalization.JulianCalendar.get_MaxSupportedDateTime +M:System.Globalization.JulianCalendar.get_MinSupportedDateTime +M:System.Globalization.JulianCalendar.get_TwoDigitYearMax +M:System.Globalization.JulianCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.JulianCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.JulianCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.JulianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.GetEra(System.DateTime) +M:System.Globalization.JulianCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.GetMonth(System.DateTime) +M:System.Globalization.JulianCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.GetYear(System.DateTime) +M:System.Globalization.JulianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.JulianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.JulianCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.KoreanCalendar.#ctor +M:System.Globalization.KoreanCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.KoreanCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.KoreanCalendar.get_AlgorithmType +M:System.Globalization.KoreanCalendar.get_Eras +M:System.Globalization.KoreanCalendar.get_MaxSupportedDateTime +M:System.Globalization.KoreanCalendar.get_MinSupportedDateTime +M:System.Globalization.KoreanCalendar.get_TwoDigitYearMax +M:System.Globalization.KoreanCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.KoreanCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.KoreanCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.KoreanCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.GetEra(System.DateTime) +M:System.Globalization.KoreanCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.GetMonth(System.DateTime) +M:System.Globalization.KoreanCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +M:System.Globalization.KoreanCalendar.GetYear(System.DateTime) +M:System.Globalization.KoreanCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.KoreanCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.KoreanCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.KoreanLunisolarCalendar.#ctor +M:System.Globalization.KoreanLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.KoreanLunisolarCalendar.get_Eras +M:System.Globalization.KoreanLunisolarCalendar.get_MaxSupportedDateTime +M:System.Globalization.KoreanLunisolarCalendar.get_MinSupportedDateTime +M:System.Globalization.KoreanLunisolarCalendar.GetEra(System.DateTime) +M:System.Globalization.NumberFormatInfo.#ctor +M:System.Globalization.NumberFormatInfo.Clone +M:System.Globalization.NumberFormatInfo.get_CurrencyDecimalDigits +M:System.Globalization.NumberFormatInfo.get_CurrencyDecimalSeparator +M:System.Globalization.NumberFormatInfo.get_CurrencyGroupSeparator +M:System.Globalization.NumberFormatInfo.get_CurrencyGroupSizes +M:System.Globalization.NumberFormatInfo.get_CurrencyNegativePattern +M:System.Globalization.NumberFormatInfo.get_CurrencyPositivePattern +M:System.Globalization.NumberFormatInfo.get_CurrencySymbol +M:System.Globalization.NumberFormatInfo.get_CurrentInfo +M:System.Globalization.NumberFormatInfo.get_DigitSubstitution +M:System.Globalization.NumberFormatInfo.get_InvariantInfo +M:System.Globalization.NumberFormatInfo.get_IsReadOnly +M:System.Globalization.NumberFormatInfo.get_NaNSymbol +M:System.Globalization.NumberFormatInfo.get_NativeDigits +M:System.Globalization.NumberFormatInfo.get_NegativeInfinitySymbol +M:System.Globalization.NumberFormatInfo.get_NegativeSign +M:System.Globalization.NumberFormatInfo.get_NumberDecimalDigits +M:System.Globalization.NumberFormatInfo.get_NumberDecimalSeparator +M:System.Globalization.NumberFormatInfo.get_NumberGroupSeparator +M:System.Globalization.NumberFormatInfo.get_NumberGroupSizes +M:System.Globalization.NumberFormatInfo.get_NumberNegativePattern +M:System.Globalization.NumberFormatInfo.get_PercentDecimalDigits +M:System.Globalization.NumberFormatInfo.get_PercentDecimalSeparator +M:System.Globalization.NumberFormatInfo.get_PercentGroupSeparator +M:System.Globalization.NumberFormatInfo.get_PercentGroupSizes +M:System.Globalization.NumberFormatInfo.get_PercentNegativePattern +M:System.Globalization.NumberFormatInfo.get_PercentPositivePattern +M:System.Globalization.NumberFormatInfo.get_PercentSymbol +M:System.Globalization.NumberFormatInfo.get_PerMilleSymbol +M:System.Globalization.NumberFormatInfo.get_PositiveInfinitySymbol +M:System.Globalization.NumberFormatInfo.get_PositiveSign +M:System.Globalization.NumberFormatInfo.GetFormat(System.Type) +M:System.Globalization.NumberFormatInfo.GetInstance(System.IFormatProvider) +M:System.Globalization.NumberFormatInfo.ReadOnly(System.Globalization.NumberFormatInfo) +M:System.Globalization.NumberFormatInfo.set_CurrencyDecimalDigits(System.Int32) +M:System.Globalization.NumberFormatInfo.set_CurrencyDecimalSeparator(System.String) +M:System.Globalization.NumberFormatInfo.set_CurrencyGroupSeparator(System.String) +M:System.Globalization.NumberFormatInfo.set_CurrencyGroupSizes(System.Int32[]) +M:System.Globalization.NumberFormatInfo.set_CurrencyNegativePattern(System.Int32) +M:System.Globalization.NumberFormatInfo.set_CurrencyPositivePattern(System.Int32) +M:System.Globalization.NumberFormatInfo.set_CurrencySymbol(System.String) +M:System.Globalization.NumberFormatInfo.set_DigitSubstitution(System.Globalization.DigitShapes) +M:System.Globalization.NumberFormatInfo.set_NaNSymbol(System.String) +M:System.Globalization.NumberFormatInfo.set_NativeDigits(System.String[]) +M:System.Globalization.NumberFormatInfo.set_NegativeInfinitySymbol(System.String) +M:System.Globalization.NumberFormatInfo.set_NegativeSign(System.String) +M:System.Globalization.NumberFormatInfo.set_NumberDecimalDigits(System.Int32) +M:System.Globalization.NumberFormatInfo.set_NumberDecimalSeparator(System.String) +M:System.Globalization.NumberFormatInfo.set_NumberGroupSeparator(System.String) +M:System.Globalization.NumberFormatInfo.set_NumberGroupSizes(System.Int32[]) +M:System.Globalization.NumberFormatInfo.set_NumberNegativePattern(System.Int32) +M:System.Globalization.NumberFormatInfo.set_PercentDecimalDigits(System.Int32) +M:System.Globalization.NumberFormatInfo.set_PercentDecimalSeparator(System.String) +M:System.Globalization.NumberFormatInfo.set_PercentGroupSeparator(System.String) +M:System.Globalization.NumberFormatInfo.set_PercentGroupSizes(System.Int32[]) +M:System.Globalization.NumberFormatInfo.set_PercentNegativePattern(System.Int32) +M:System.Globalization.NumberFormatInfo.set_PercentPositivePattern(System.Int32) +M:System.Globalization.NumberFormatInfo.set_PercentSymbol(System.String) +M:System.Globalization.NumberFormatInfo.set_PerMilleSymbol(System.String) +M:System.Globalization.NumberFormatInfo.set_PositiveInfinitySymbol(System.String) +M:System.Globalization.NumberFormatInfo.set_PositiveSign(System.String) +M:System.Globalization.PersianCalendar.#ctor +M:System.Globalization.PersianCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.PersianCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.PersianCalendar.get_AlgorithmType +M:System.Globalization.PersianCalendar.get_Eras +M:System.Globalization.PersianCalendar.get_MaxSupportedDateTime +M:System.Globalization.PersianCalendar.get_MinSupportedDateTime +M:System.Globalization.PersianCalendar.get_TwoDigitYearMax +M:System.Globalization.PersianCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.PersianCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.PersianCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.PersianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.GetEra(System.DateTime) +M:System.Globalization.PersianCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.GetMonth(System.DateTime) +M:System.Globalization.PersianCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.GetYear(System.DateTime) +M:System.Globalization.PersianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.PersianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.PersianCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.RegionInfo.#ctor(System.Int32) +M:System.Globalization.RegionInfo.#ctor(System.String) +M:System.Globalization.RegionInfo.Equals(System.Object) +M:System.Globalization.RegionInfo.get_CurrencyEnglishName +M:System.Globalization.RegionInfo.get_CurrencyNativeName +M:System.Globalization.RegionInfo.get_CurrencySymbol +M:System.Globalization.RegionInfo.get_CurrentRegion +M:System.Globalization.RegionInfo.get_DisplayName +M:System.Globalization.RegionInfo.get_EnglishName +M:System.Globalization.RegionInfo.get_GeoId +M:System.Globalization.RegionInfo.get_IsMetric +M:System.Globalization.RegionInfo.get_ISOCurrencySymbol +M:System.Globalization.RegionInfo.get_Name +M:System.Globalization.RegionInfo.get_NativeName +M:System.Globalization.RegionInfo.get_ThreeLetterISORegionName +M:System.Globalization.RegionInfo.get_ThreeLetterWindowsRegionName +M:System.Globalization.RegionInfo.get_TwoLetterISORegionName +M:System.Globalization.RegionInfo.GetHashCode +M:System.Globalization.RegionInfo.ToString +M:System.Globalization.SortKey.Compare(System.Globalization.SortKey,System.Globalization.SortKey) +M:System.Globalization.SortKey.Equals(System.Object) +M:System.Globalization.SortKey.get_KeyData +M:System.Globalization.SortKey.get_OriginalString +M:System.Globalization.SortKey.GetHashCode +M:System.Globalization.SortKey.ToString +M:System.Globalization.SortVersion.#ctor(System.Int32,System.Guid) +M:System.Globalization.SortVersion.Equals(System.Globalization.SortVersion) +M:System.Globalization.SortVersion.Equals(System.Object) +M:System.Globalization.SortVersion.get_FullVersion +M:System.Globalization.SortVersion.get_SortId +M:System.Globalization.SortVersion.GetHashCode +M:System.Globalization.SortVersion.op_Equality(System.Globalization.SortVersion,System.Globalization.SortVersion) +M:System.Globalization.SortVersion.op_Inequality(System.Globalization.SortVersion,System.Globalization.SortVersion) +M:System.Globalization.StringInfo.#ctor +M:System.Globalization.StringInfo.#ctor(System.String) +M:System.Globalization.StringInfo.Equals(System.Object) +M:System.Globalization.StringInfo.get_LengthInTextElements +M:System.Globalization.StringInfo.get_String +M:System.Globalization.StringInfo.GetHashCode +M:System.Globalization.StringInfo.GetNextTextElement(System.String) +M:System.Globalization.StringInfo.GetNextTextElement(System.String,System.Int32) +M:System.Globalization.StringInfo.GetNextTextElementLength(System.ReadOnlySpan{System.Char}) +M:System.Globalization.StringInfo.GetNextTextElementLength(System.String) +M:System.Globalization.StringInfo.GetNextTextElementLength(System.String,System.Int32) +M:System.Globalization.StringInfo.GetTextElementEnumerator(System.String) +M:System.Globalization.StringInfo.GetTextElementEnumerator(System.String,System.Int32) +M:System.Globalization.StringInfo.ParseCombiningCharacters(System.String) +M:System.Globalization.StringInfo.set_String(System.String) +M:System.Globalization.StringInfo.SubstringByTextElements(System.Int32) +M:System.Globalization.StringInfo.SubstringByTextElements(System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.#ctor +M:System.Globalization.TaiwanCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.TaiwanCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.TaiwanCalendar.get_AlgorithmType +M:System.Globalization.TaiwanCalendar.get_Eras +M:System.Globalization.TaiwanCalendar.get_MaxSupportedDateTime +M:System.Globalization.TaiwanCalendar.get_MinSupportedDateTime +M:System.Globalization.TaiwanCalendar.get_TwoDigitYearMax +M:System.Globalization.TaiwanCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.TaiwanCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.TaiwanCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.TaiwanCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.GetEra(System.DateTime) +M:System.Globalization.TaiwanCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.GetMonth(System.DateTime) +M:System.Globalization.TaiwanCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +M:System.Globalization.TaiwanCalendar.GetYear(System.DateTime) +M:System.Globalization.TaiwanCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.TaiwanCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.TaiwanCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.TaiwanLunisolarCalendar.#ctor +M:System.Globalization.TaiwanLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.TaiwanLunisolarCalendar.get_Eras +M:System.Globalization.TaiwanLunisolarCalendar.get_MaxSupportedDateTime +M:System.Globalization.TaiwanLunisolarCalendar.get_MinSupportedDateTime +M:System.Globalization.TaiwanLunisolarCalendar.GetEra(System.DateTime) +M:System.Globalization.TextElementEnumerator.get_Current +M:System.Globalization.TextElementEnumerator.get_ElementIndex +M:System.Globalization.TextElementEnumerator.GetTextElement +M:System.Globalization.TextElementEnumerator.MoveNext +M:System.Globalization.TextElementEnumerator.Reset +M:System.Globalization.TextInfo.Clone +M:System.Globalization.TextInfo.Equals(System.Object) +M:System.Globalization.TextInfo.get_ANSICodePage +M:System.Globalization.TextInfo.get_CultureName +M:System.Globalization.TextInfo.get_EBCDICCodePage +M:System.Globalization.TextInfo.get_IsReadOnly +M:System.Globalization.TextInfo.get_IsRightToLeft +M:System.Globalization.TextInfo.get_LCID +M:System.Globalization.TextInfo.get_ListSeparator +M:System.Globalization.TextInfo.get_MacCodePage +M:System.Globalization.TextInfo.get_OEMCodePage +M:System.Globalization.TextInfo.GetHashCode +M:System.Globalization.TextInfo.ReadOnly(System.Globalization.TextInfo) +M:System.Globalization.TextInfo.set_ListSeparator(System.String) +M:System.Globalization.TextInfo.ToLower(System.Char) +M:System.Globalization.TextInfo.ToLower(System.String) +M:System.Globalization.TextInfo.ToString +M:System.Globalization.TextInfo.ToTitleCase(System.String) +M:System.Globalization.TextInfo.ToUpper(System.Char) +M:System.Globalization.TextInfo.ToUpper(System.String) +M:System.Globalization.ThaiBuddhistCalendar.#ctor +M:System.Globalization.ThaiBuddhistCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.get_AlgorithmType +M:System.Globalization.ThaiBuddhistCalendar.get_Eras +M:System.Globalization.ThaiBuddhistCalendar.get_MaxSupportedDateTime +M:System.Globalization.ThaiBuddhistCalendar.get_MinSupportedDateTime +M:System.Globalization.ThaiBuddhistCalendar.get_TwoDigitYearMax +M:System.Globalization.ThaiBuddhistCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.ThaiBuddhistCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.ThaiBuddhistCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.ThaiBuddhistCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.GetEra(System.DateTime) +M:System.Globalization.ThaiBuddhistCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.GetMonth(System.DateTime) +M:System.Globalization.ThaiBuddhistCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) +M:System.Globalization.ThaiBuddhistCalendar.GetYear(System.DateTime) +M:System.Globalization.ThaiBuddhistCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.ThaiBuddhistCalendar.ToFourDigitYear(System.Int32) +M:System.Globalization.UmAlQuraCalendar.#ctor +M:System.Globalization.UmAlQuraCalendar.AddMonths(System.DateTime,System.Int32) +M:System.Globalization.UmAlQuraCalendar.AddYears(System.DateTime,System.Int32) +M:System.Globalization.UmAlQuraCalendar.get_AlgorithmType +M:System.Globalization.UmAlQuraCalendar.get_DaysInYearBeforeMinSupportedYear +M:System.Globalization.UmAlQuraCalendar.get_Eras +M:System.Globalization.UmAlQuraCalendar.get_MaxSupportedDateTime +M:System.Globalization.UmAlQuraCalendar.get_MinSupportedDateTime +M:System.Globalization.UmAlQuraCalendar.get_TwoDigitYearMax +M:System.Globalization.UmAlQuraCalendar.GetDayOfMonth(System.DateTime) +M:System.Globalization.UmAlQuraCalendar.GetDayOfWeek(System.DateTime) +M:System.Globalization.UmAlQuraCalendar.GetDayOfYear(System.DateTime) +M:System.Globalization.UmAlQuraCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.GetDaysInYear(System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.GetEra(System.DateTime) +M:System.Globalization.UmAlQuraCalendar.GetLeapMonth(System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.GetMonth(System.DateTime) +M:System.Globalization.UmAlQuraCalendar.GetMonthsInYear(System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.GetYear(System.DateTime) +M:System.Globalization.UmAlQuraCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.IsLeapYear(System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.set_TwoDigitYearMax(System.Int32) +M:System.Globalization.UmAlQuraCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Globalization.UmAlQuraCalendar.ToFourDigitYear(System.Int32) +M:System.GopherStyleUriParser.#ctor +M:System.Guid.#ctor(System.Byte[]) +M:System.Guid.#ctor(System.Int32,System.Int16,System.Int16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) +M:System.Guid.#ctor(System.Int32,System.Int16,System.Int16,System.Byte[]) +M:System.Guid.#ctor(System.ReadOnlySpan{System.Byte}) +M:System.Guid.#ctor(System.ReadOnlySpan{System.Byte},System.Boolean) +M:System.Guid.#ctor(System.String) +M:System.Guid.#ctor(System.UInt32,System.UInt16,System.UInt16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) +M:System.Guid.CompareTo(System.Guid) +M:System.Guid.CompareTo(System.Object) +M:System.Guid.Equals(System.Guid) +M:System.Guid.Equals(System.Object) +M:System.Guid.GetHashCode +M:System.Guid.NewGuid +M:System.Guid.op_Equality(System.Guid,System.Guid) +M:System.Guid.op_GreaterThan(System.Guid,System.Guid) +M:System.Guid.op_GreaterThanOrEqual(System.Guid,System.Guid) +M:System.Guid.op_Inequality(System.Guid,System.Guid) +M:System.Guid.op_LessThan(System.Guid,System.Guid) +M:System.Guid.op_LessThanOrEqual(System.Guid,System.Guid) +M:System.Guid.Parse(System.ReadOnlySpan{System.Char}) +M:System.Guid.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Guid.Parse(System.String) +M:System.Guid.Parse(System.String,System.IFormatProvider) +M:System.Guid.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:System.Guid.ParseExact(System.String,System.String) +M:System.Guid.ToByteArray +M:System.Guid.ToByteArray(System.Boolean) +M:System.Guid.ToString +M:System.Guid.ToString(System.String) +M:System.Guid.ToString(System.String,System.IFormatProvider) +M:System.Guid.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char}) +M:System.Guid.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char}) +M:System.Guid.TryParse(System.ReadOnlySpan{System.Char},System.Guid@) +M:System.Guid.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Guid@) +M:System.Guid.TryParse(System.String,System.Guid@) +M:System.Guid.TryParse(System.String,System.IFormatProvider,System.Guid@) +M:System.Guid.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Guid@) +M:System.Guid.TryParseExact(System.String,System.String,System.Guid@) +M:System.Guid.TryWriteBytes(System.Span{System.Byte}) +M:System.Guid.TryWriteBytes(System.Span{System.Byte},System.Boolean,System.Int32@) +M:System.Half.Abs(System.Half) +M:System.Half.Acos(System.Half) +M:System.Half.Acosh(System.Half) +M:System.Half.AcosPi(System.Half) +M:System.Half.Asin(System.Half) +M:System.Half.Asinh(System.Half) +M:System.Half.AsinPi(System.Half) +M:System.Half.Atan(System.Half) +M:System.Half.Atan2(System.Half,System.Half) +M:System.Half.Atan2Pi(System.Half,System.Half) +M:System.Half.Atanh(System.Half) +M:System.Half.AtanPi(System.Half) +M:System.Half.BitDecrement(System.Half) +M:System.Half.BitIncrement(System.Half) +M:System.Half.Cbrt(System.Half) +M:System.Half.Ceiling(System.Half) +M:System.Half.Clamp(System.Half,System.Half,System.Half) +M:System.Half.CompareTo(System.Half) +M:System.Half.CompareTo(System.Object) +M:System.Half.CopySign(System.Half,System.Half) +M:System.Half.Cos(System.Half) +M:System.Half.Cosh(System.Half) +M:System.Half.CosPi(System.Half) +M:System.Half.CreateChecked``1(``0) +M:System.Half.CreateSaturating``1(``0) +M:System.Half.CreateTruncating``1(``0) +M:System.Half.DegreesToRadians(System.Half) +M:System.Half.Equals(System.Half) +M:System.Half.Equals(System.Object) +M:System.Half.Exp(System.Half) +M:System.Half.Exp10(System.Half) +M:System.Half.Exp10M1(System.Half) +M:System.Half.Exp2(System.Half) +M:System.Half.Exp2M1(System.Half) +M:System.Half.ExpM1(System.Half) +M:System.Half.Floor(System.Half) +M:System.Half.FusedMultiplyAdd(System.Half,System.Half,System.Half) +M:System.Half.get_E +M:System.Half.get_Epsilon +M:System.Half.get_MaxValue +M:System.Half.get_MinValue +M:System.Half.get_MultiplicativeIdentity +M:System.Half.get_NaN +M:System.Half.get_NegativeInfinity +M:System.Half.get_NegativeOne +M:System.Half.get_NegativeZero +M:System.Half.get_One +M:System.Half.get_Pi +M:System.Half.get_PositiveInfinity +M:System.Half.get_Tau +M:System.Half.get_Zero +M:System.Half.GetHashCode +M:System.Half.Hypot(System.Half,System.Half) +M:System.Half.Ieee754Remainder(System.Half,System.Half) +M:System.Half.ILogB(System.Half) +M:System.Half.IsEvenInteger(System.Half) +M:System.Half.IsFinite(System.Half) +M:System.Half.IsInfinity(System.Half) +M:System.Half.IsInteger(System.Half) +M:System.Half.IsNaN(System.Half) +M:System.Half.IsNegative(System.Half) +M:System.Half.IsNegativeInfinity(System.Half) +M:System.Half.IsNormal(System.Half) +M:System.Half.IsOddInteger(System.Half) +M:System.Half.IsPositive(System.Half) +M:System.Half.IsPositiveInfinity(System.Half) +M:System.Half.IsPow2(System.Half) +M:System.Half.IsRealNumber(System.Half) +M:System.Half.IsSubnormal(System.Half) +M:System.Half.Lerp(System.Half,System.Half,System.Half) +M:System.Half.Log(System.Half) +M:System.Half.Log(System.Half,System.Half) +M:System.Half.Log10(System.Half) +M:System.Half.Log10P1(System.Half) +M:System.Half.Log2(System.Half) +M:System.Half.Log2P1(System.Half) +M:System.Half.LogP1(System.Half) +M:System.Half.Max(System.Half,System.Half) +M:System.Half.MaxMagnitude(System.Half,System.Half) +M:System.Half.MaxMagnitudeNumber(System.Half,System.Half) +M:System.Half.MaxNumber(System.Half,System.Half) +M:System.Half.Min(System.Half,System.Half) +M:System.Half.MinMagnitude(System.Half,System.Half) +M:System.Half.MinMagnitudeNumber(System.Half,System.Half) +M:System.Half.MinNumber(System.Half,System.Half) +M:System.Half.op_Addition(System.Half,System.Half) +M:System.Half.op_CheckedExplicit(System.Half)~System.Byte +M:System.Half.op_CheckedExplicit(System.Half)~System.Char +M:System.Half.op_CheckedExplicit(System.Half)~System.Int128 +M:System.Half.op_CheckedExplicit(System.Half)~System.Int16 +M:System.Half.op_CheckedExplicit(System.Half)~System.Int32 +M:System.Half.op_CheckedExplicit(System.Half)~System.Int64 +M:System.Half.op_CheckedExplicit(System.Half)~System.IntPtr +M:System.Half.op_CheckedExplicit(System.Half)~System.SByte +M:System.Half.op_CheckedExplicit(System.Half)~System.UInt128 +M:System.Half.op_CheckedExplicit(System.Half)~System.UInt16 +M:System.Half.op_CheckedExplicit(System.Half)~System.UInt32 +M:System.Half.op_CheckedExplicit(System.Half)~System.UInt64 +M:System.Half.op_CheckedExplicit(System.Half)~System.UIntPtr +M:System.Half.op_Decrement(System.Half) +M:System.Half.op_Division(System.Half,System.Half) +M:System.Half.op_Equality(System.Half,System.Half) +M:System.Half.op_Explicit(System.Char)~System.Half +M:System.Half.op_Explicit(System.Decimal)~System.Half +M:System.Half.op_Explicit(System.Double)~System.Half +M:System.Half.op_Explicit(System.Half)~System.Byte +M:System.Half.op_Explicit(System.Half)~System.Char +M:System.Half.op_Explicit(System.Half)~System.Decimal +M:System.Half.op_Explicit(System.Half)~System.Double +M:System.Half.op_Explicit(System.Half)~System.Int128 +M:System.Half.op_Explicit(System.Half)~System.Int16 +M:System.Half.op_Explicit(System.Half)~System.Int32 +M:System.Half.op_Explicit(System.Half)~System.Int64 +M:System.Half.op_Explicit(System.Half)~System.IntPtr +M:System.Half.op_Explicit(System.Half)~System.SByte +M:System.Half.op_Explicit(System.Half)~System.Single +M:System.Half.op_Explicit(System.Half)~System.UInt128 +M:System.Half.op_Explicit(System.Half)~System.UInt16 +M:System.Half.op_Explicit(System.Half)~System.UInt32 +M:System.Half.op_Explicit(System.Half)~System.UInt64 +M:System.Half.op_Explicit(System.Half)~System.UIntPtr +M:System.Half.op_Explicit(System.Int16)~System.Half +M:System.Half.op_Explicit(System.Int32)~System.Half +M:System.Half.op_Explicit(System.Int64)~System.Half +M:System.Half.op_Explicit(System.IntPtr)~System.Half +M:System.Half.op_Explicit(System.Single)~System.Half +M:System.Half.op_Explicit(System.UInt16)~System.Half +M:System.Half.op_Explicit(System.UInt32)~System.Half +M:System.Half.op_Explicit(System.UInt64)~System.Half +M:System.Half.op_Explicit(System.UIntPtr)~System.Half +M:System.Half.op_GreaterThan(System.Half,System.Half) +M:System.Half.op_GreaterThanOrEqual(System.Half,System.Half) +M:System.Half.op_Implicit(System.Byte)~System.Half +M:System.Half.op_Implicit(System.SByte)~System.Half +M:System.Half.op_Increment(System.Half) +M:System.Half.op_Inequality(System.Half,System.Half) +M:System.Half.op_LessThan(System.Half,System.Half) +M:System.Half.op_LessThanOrEqual(System.Half,System.Half) +M:System.Half.op_Modulus(System.Half,System.Half) +M:System.Half.op_Multiply(System.Half,System.Half) +M:System.Half.op_Subtraction(System.Half,System.Half) +M:System.Half.op_UnaryNegation(System.Half) +M:System.Half.op_UnaryPlus(System.Half) +M:System.Half.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Half.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Half.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Half.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Half.Parse(System.String) +M:System.Half.Parse(System.String,System.Globalization.NumberStyles) +M:System.Half.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Half.Parse(System.String,System.IFormatProvider) +M:System.Half.Pow(System.Half,System.Half) +M:System.Half.RadiansToDegrees(System.Half) +M:System.Half.ReciprocalEstimate(System.Half) +M:System.Half.ReciprocalSqrtEstimate(System.Half) +M:System.Half.RootN(System.Half,System.Int32) +M:System.Half.Round(System.Half) +M:System.Half.Round(System.Half,System.Int32) +M:System.Half.Round(System.Half,System.Int32,System.MidpointRounding) +M:System.Half.Round(System.Half,System.MidpointRounding) +M:System.Half.ScaleB(System.Half,System.Int32) +M:System.Half.Sign(System.Half) +M:System.Half.Sin(System.Half) +M:System.Half.SinCos(System.Half) +M:System.Half.SinCosPi(System.Half) +M:System.Half.Sinh(System.Half) +M:System.Half.SinPi(System.Half) +M:System.Half.Sqrt(System.Half) +M:System.Half.Tan(System.Half) +M:System.Half.Tanh(System.Half) +M:System.Half.TanPi(System.Half) +M:System.Half.ToString +M:System.Half.ToString(System.IFormatProvider) +M:System.Half.ToString(System.String) +M:System.Half.ToString(System.String,System.IFormatProvider) +M:System.Half.Truncate(System.Half) +M:System.Half.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Half.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) +M:System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.Half@) +M:System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Half@) +M:System.Half.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) +M:System.Half.TryParse(System.ReadOnlySpan{System.Char},System.Half@) +M:System.Half.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Half@) +M:System.Half.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) +M:System.Half.TryParse(System.String,System.Half@) +M:System.Half.TryParse(System.String,System.IFormatProvider,System.Half@) +M:System.HashCode.Add``1(``0) +M:System.HashCode.Add``1(``0,System.Collections.Generic.IEqualityComparer{``0}) +M:System.HashCode.AddBytes(System.ReadOnlySpan{System.Byte}) +M:System.HashCode.Combine``1(``0) +M:System.HashCode.Combine``2(``0,``1) +M:System.HashCode.Combine``3(``0,``1,``2) +M:System.HashCode.Combine``4(``0,``1,``2,``3) +M:System.HashCode.Combine``5(``0,``1,``2,``3,``4) +M:System.HashCode.Combine``6(``0,``1,``2,``3,``4,``5) +M:System.HashCode.Combine``7(``0,``1,``2,``3,``4,``5,``6) +M:System.HashCode.Combine``8(``0,``1,``2,``3,``4,``5,``6,``7) +M:System.HashCode.Equals(System.Object) +M:System.HashCode.GetHashCode +M:System.HashCode.ToHashCode +M:System.HttpStyleUriParser.#ctor +M:System.IAsyncDisposable.DisposeAsync +M:System.IAsyncResult.get_AsyncState +M:System.IAsyncResult.get_AsyncWaitHandle +M:System.IAsyncResult.get_CompletedSynchronously +M:System.IAsyncResult.get_IsCompleted +M:System.ICloneable.Clone +M:System.IComparable.CompareTo(System.Object) +M:System.IComparable`1.CompareTo(`0) +M:System.IConvertible.GetTypeCode +M:System.IConvertible.ToBoolean(System.IFormatProvider) +M:System.IConvertible.ToByte(System.IFormatProvider) +M:System.IConvertible.ToChar(System.IFormatProvider) +M:System.IConvertible.ToDateTime(System.IFormatProvider) +M:System.IConvertible.ToDecimal(System.IFormatProvider) +M:System.IConvertible.ToDouble(System.IFormatProvider) +M:System.IConvertible.ToInt16(System.IFormatProvider) +M:System.IConvertible.ToInt32(System.IFormatProvider) +M:System.IConvertible.ToInt64(System.IFormatProvider) +M:System.IConvertible.ToSByte(System.IFormatProvider) +M:System.IConvertible.ToSingle(System.IFormatProvider) +M:System.IConvertible.ToString(System.IFormatProvider) +M:System.IConvertible.ToType(System.Type,System.IFormatProvider) +M:System.IConvertible.ToUInt16(System.IFormatProvider) +M:System.IConvertible.ToUInt32(System.IFormatProvider) +M:System.IConvertible.ToUInt64(System.IFormatProvider) +M:System.ICustomFormatter.Format(System.String,System.Object,System.IFormatProvider) +M:System.IDisposable.Dispose +M:System.IEquatable`1.Equals(`0) +M:System.IFormatProvider.GetFormat(System.Type) +M:System.IFormattable.ToString(System.String,System.IFormatProvider) +M:System.Index.#ctor(System.Int32,System.Boolean) +M:System.Index.Equals(System.Index) +M:System.Index.Equals(System.Object) +M:System.Index.FromEnd(System.Int32) +M:System.Index.FromStart(System.Int32) +M:System.Index.get_End +M:System.Index.get_IsFromEnd +M:System.Index.get_Start +M:System.Index.get_Value +M:System.Index.GetHashCode +M:System.Index.GetOffset(System.Int32) +M:System.Index.op_Implicit(System.Int32)~System.Index +M:System.Index.ToString +M:System.IndexOutOfRangeException.#ctor +M:System.IndexOutOfRangeException.#ctor(System.String) +M:System.IndexOutOfRangeException.#ctor(System.String,System.Exception) +M:System.InsufficientExecutionStackException.#ctor +M:System.InsufficientExecutionStackException.#ctor(System.String) +M:System.InsufficientExecutionStackException.#ctor(System.String,System.Exception) +M:System.InsufficientMemoryException.#ctor +M:System.InsufficientMemoryException.#ctor(System.String) +M:System.InsufficientMemoryException.#ctor(System.String,System.Exception) +M:System.Int128.#ctor(System.UInt64,System.UInt64) +M:System.Int128.Abs(System.Int128) +M:System.Int128.Clamp(System.Int128,System.Int128,System.Int128) +M:System.Int128.CompareTo(System.Int128) +M:System.Int128.CompareTo(System.Object) +M:System.Int128.CopySign(System.Int128,System.Int128) +M:System.Int128.CreateChecked``1(``0) +M:System.Int128.CreateSaturating``1(``0) +M:System.Int128.CreateTruncating``1(``0) +M:System.Int128.DivRem(System.Int128,System.Int128) +M:System.Int128.Equals(System.Int128) +M:System.Int128.Equals(System.Object) +M:System.Int128.get_MaxValue +M:System.Int128.get_MinValue +M:System.Int128.get_NegativeOne +M:System.Int128.get_One +M:System.Int128.get_Zero +M:System.Int128.GetHashCode +M:System.Int128.IsEvenInteger(System.Int128) +M:System.Int128.IsNegative(System.Int128) +M:System.Int128.IsOddInteger(System.Int128) +M:System.Int128.IsPositive(System.Int128) +M:System.Int128.IsPow2(System.Int128) +M:System.Int128.LeadingZeroCount(System.Int128) +M:System.Int128.Log2(System.Int128) +M:System.Int128.Max(System.Int128,System.Int128) +M:System.Int128.MaxMagnitude(System.Int128,System.Int128) +M:System.Int128.Min(System.Int128,System.Int128) +M:System.Int128.MinMagnitude(System.Int128,System.Int128) +M:System.Int128.op_Addition(System.Int128,System.Int128) +M:System.Int128.op_BitwiseAnd(System.Int128,System.Int128) +M:System.Int128.op_BitwiseOr(System.Int128,System.Int128) +M:System.Int128.op_CheckedAddition(System.Int128,System.Int128) +M:System.Int128.op_CheckedDecrement(System.Int128) +M:System.Int128.op_CheckedDivision(System.Int128,System.Int128) +M:System.Int128.op_CheckedExplicit(System.Double)~System.Int128 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.Byte +M:System.Int128.op_CheckedExplicit(System.Int128)~System.Char +M:System.Int128.op_CheckedExplicit(System.Int128)~System.Int16 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.Int32 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.Int64 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.IntPtr +M:System.Int128.op_CheckedExplicit(System.Int128)~System.SByte +M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt128 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt16 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt32 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt64 +M:System.Int128.op_CheckedExplicit(System.Int128)~System.UIntPtr +M:System.Int128.op_CheckedExplicit(System.Single)~System.Int128 +M:System.Int128.op_CheckedIncrement(System.Int128) +M:System.Int128.op_CheckedMultiply(System.Int128,System.Int128) +M:System.Int128.op_CheckedSubtraction(System.Int128,System.Int128) +M:System.Int128.op_CheckedUnaryNegation(System.Int128) +M:System.Int128.op_Decrement(System.Int128) +M:System.Int128.op_Division(System.Int128,System.Int128) +M:System.Int128.op_Equality(System.Int128,System.Int128) +M:System.Int128.op_ExclusiveOr(System.Int128,System.Int128) +M:System.Int128.op_Explicit(System.Decimal)~System.Int128 +M:System.Int128.op_Explicit(System.Double)~System.Int128 +M:System.Int128.op_Explicit(System.Int128)~System.Byte +M:System.Int128.op_Explicit(System.Int128)~System.Char +M:System.Int128.op_Explicit(System.Int128)~System.Decimal +M:System.Int128.op_Explicit(System.Int128)~System.Double +M:System.Int128.op_Explicit(System.Int128)~System.Half +M:System.Int128.op_Explicit(System.Int128)~System.Int16 +M:System.Int128.op_Explicit(System.Int128)~System.Int32 +M:System.Int128.op_Explicit(System.Int128)~System.Int64 +M:System.Int128.op_Explicit(System.Int128)~System.IntPtr +M:System.Int128.op_Explicit(System.Int128)~System.SByte +M:System.Int128.op_Explicit(System.Int128)~System.Single +M:System.Int128.op_Explicit(System.Int128)~System.UInt128 +M:System.Int128.op_Explicit(System.Int128)~System.UInt16 +M:System.Int128.op_Explicit(System.Int128)~System.UInt32 +M:System.Int128.op_Explicit(System.Int128)~System.UInt64 +M:System.Int128.op_Explicit(System.Int128)~System.UIntPtr +M:System.Int128.op_Explicit(System.Single)~System.Int128 +M:System.Int128.op_GreaterThan(System.Int128,System.Int128) +M:System.Int128.op_GreaterThanOrEqual(System.Int128,System.Int128) +M:System.Int128.op_Implicit(System.Byte)~System.Int128 +M:System.Int128.op_Implicit(System.Char)~System.Int128 +M:System.Int128.op_Implicit(System.Int16)~System.Int128 +M:System.Int128.op_Implicit(System.Int32)~System.Int128 +M:System.Int128.op_Implicit(System.Int64)~System.Int128 +M:System.Int128.op_Implicit(System.IntPtr)~System.Int128 +M:System.Int128.op_Implicit(System.SByte)~System.Int128 +M:System.Int128.op_Implicit(System.UInt16)~System.Int128 +M:System.Int128.op_Implicit(System.UInt32)~System.Int128 +M:System.Int128.op_Implicit(System.UInt64)~System.Int128 +M:System.Int128.op_Implicit(System.UIntPtr)~System.Int128 +M:System.Int128.op_Increment(System.Int128) +M:System.Int128.op_Inequality(System.Int128,System.Int128) +M:System.Int128.op_LeftShift(System.Int128,System.Int32) +M:System.Int128.op_LessThan(System.Int128,System.Int128) +M:System.Int128.op_LessThanOrEqual(System.Int128,System.Int128) +M:System.Int128.op_Modulus(System.Int128,System.Int128) +M:System.Int128.op_Multiply(System.Int128,System.Int128) +M:System.Int128.op_OnesComplement(System.Int128) +M:System.Int128.op_RightShift(System.Int128,System.Int32) +M:System.Int128.op_Subtraction(System.Int128,System.Int128) +M:System.Int128.op_UnaryNegation(System.Int128) +M:System.Int128.op_UnaryPlus(System.Int128) +M:System.Int128.op_UnsignedRightShift(System.Int128,System.Int32) +M:System.Int128.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int128.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Int128.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int128.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int128.Parse(System.String) +M:System.Int128.Parse(System.String,System.Globalization.NumberStyles) +M:System.Int128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int128.Parse(System.String,System.IFormatProvider) +M:System.Int128.PopCount(System.Int128) +M:System.Int128.RotateLeft(System.Int128,System.Int32) +M:System.Int128.RotateRight(System.Int128,System.Int32) +M:System.Int128.Sign(System.Int128) +M:System.Int128.ToString +M:System.Int128.ToString(System.IFormatProvider) +M:System.Int128.ToString(System.String) +M:System.Int128.ToString(System.String,System.IFormatProvider) +M:System.Int128.TrailingZeroCount(System.Int128) +M:System.Int128.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int128.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) +M:System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int128@) +M:System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.Int128@) +M:System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) +M:System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int128@) +M:System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.Int128@) +M:System.Int128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) +M:System.Int128.TryParse(System.String,System.IFormatProvider,System.Int128@) +M:System.Int128.TryParse(System.String,System.Int128@) +M:System.Int16.Abs(System.Int16) +M:System.Int16.Clamp(System.Int16,System.Int16,System.Int16) +M:System.Int16.CompareTo(System.Int16) +M:System.Int16.CompareTo(System.Object) +M:System.Int16.CopySign(System.Int16,System.Int16) +M:System.Int16.CreateChecked``1(``0) +M:System.Int16.CreateSaturating``1(``0) +M:System.Int16.CreateTruncating``1(``0) +M:System.Int16.DivRem(System.Int16,System.Int16) +M:System.Int16.Equals(System.Int16) +M:System.Int16.Equals(System.Object) +M:System.Int16.GetHashCode +M:System.Int16.GetTypeCode +M:System.Int16.IsEvenInteger(System.Int16) +M:System.Int16.IsNegative(System.Int16) +M:System.Int16.IsOddInteger(System.Int16) +M:System.Int16.IsPositive(System.Int16) +M:System.Int16.IsPow2(System.Int16) +M:System.Int16.LeadingZeroCount(System.Int16) +M:System.Int16.Log2(System.Int16) +M:System.Int16.Max(System.Int16,System.Int16) +M:System.Int16.MaxMagnitude(System.Int16,System.Int16) +M:System.Int16.Min(System.Int16,System.Int16) +M:System.Int16.MinMagnitude(System.Int16,System.Int16) +M:System.Int16.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int16.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Int16.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int16.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int16.Parse(System.String) +M:System.Int16.Parse(System.String,System.Globalization.NumberStyles) +M:System.Int16.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int16.Parse(System.String,System.IFormatProvider) +M:System.Int16.PopCount(System.Int16) +M:System.Int16.RotateLeft(System.Int16,System.Int32) +M:System.Int16.RotateRight(System.Int16,System.Int32) +M:System.Int16.Sign(System.Int16) +M:System.Int16.ToString +M:System.Int16.ToString(System.IFormatProvider) +M:System.Int16.ToString(System.String) +M:System.Int16.ToString(System.String,System.IFormatProvider) +M:System.Int16.TrailingZeroCount(System.Int16) +M:System.Int16.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int16.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) +M:System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int16@) +M:System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.Int16@) +M:System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) +M:System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int16@) +M:System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.Int16@) +M:System.Int16.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) +M:System.Int16.TryParse(System.String,System.IFormatProvider,System.Int16@) +M:System.Int16.TryParse(System.String,System.Int16@) +M:System.Int32.Abs(System.Int32) +M:System.Int32.Clamp(System.Int32,System.Int32,System.Int32) +M:System.Int32.CompareTo(System.Int32) +M:System.Int32.CompareTo(System.Object) +M:System.Int32.CopySign(System.Int32,System.Int32) +M:System.Int32.CreateChecked``1(``0) +M:System.Int32.CreateSaturating``1(``0) +M:System.Int32.CreateTruncating``1(``0) +M:System.Int32.DivRem(System.Int32,System.Int32) +M:System.Int32.Equals(System.Int32) +M:System.Int32.Equals(System.Object) +M:System.Int32.GetHashCode +M:System.Int32.GetTypeCode +M:System.Int32.IsEvenInteger(System.Int32) +M:System.Int32.IsNegative(System.Int32) +M:System.Int32.IsOddInteger(System.Int32) +M:System.Int32.IsPositive(System.Int32) +M:System.Int32.IsPow2(System.Int32) +M:System.Int32.LeadingZeroCount(System.Int32) +M:System.Int32.Log2(System.Int32) +M:System.Int32.Max(System.Int32,System.Int32) +M:System.Int32.MaxMagnitude(System.Int32,System.Int32) +M:System.Int32.Min(System.Int32,System.Int32) +M:System.Int32.MinMagnitude(System.Int32,System.Int32) +M:System.Int32.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int32.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Int32.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int32.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int32.Parse(System.String) +M:System.Int32.Parse(System.String,System.Globalization.NumberStyles) +M:System.Int32.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int32.Parse(System.String,System.IFormatProvider) +M:System.Int32.PopCount(System.Int32) +M:System.Int32.RotateLeft(System.Int32,System.Int32) +M:System.Int32.RotateRight(System.Int32,System.Int32) +M:System.Int32.Sign(System.Int32) +M:System.Int32.ToString +M:System.Int32.ToString(System.IFormatProvider) +M:System.Int32.ToString(System.String) +M:System.Int32.ToString(System.String,System.IFormatProvider) +M:System.Int32.TrailingZeroCount(System.Int32) +M:System.Int32.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int32.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) +M:System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int32@) +M:System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.Int32@) +M:System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) +M:System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int32@) +M:System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.Int32@) +M:System.Int32.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) +M:System.Int32.TryParse(System.String,System.IFormatProvider,System.Int32@) +M:System.Int32.TryParse(System.String,System.Int32@) +M:System.Int64.Abs(System.Int64) +M:System.Int64.Clamp(System.Int64,System.Int64,System.Int64) +M:System.Int64.CompareTo(System.Int64) +M:System.Int64.CompareTo(System.Object) +M:System.Int64.CopySign(System.Int64,System.Int64) +M:System.Int64.CreateChecked``1(``0) +M:System.Int64.CreateSaturating``1(``0) +M:System.Int64.CreateTruncating``1(``0) +M:System.Int64.DivRem(System.Int64,System.Int64) +M:System.Int64.Equals(System.Int64) +M:System.Int64.Equals(System.Object) +M:System.Int64.GetHashCode +M:System.Int64.GetTypeCode +M:System.Int64.IsEvenInteger(System.Int64) +M:System.Int64.IsNegative(System.Int64) +M:System.Int64.IsOddInteger(System.Int64) +M:System.Int64.IsPositive(System.Int64) +M:System.Int64.IsPow2(System.Int64) +M:System.Int64.LeadingZeroCount(System.Int64) +M:System.Int64.Log2(System.Int64) +M:System.Int64.Max(System.Int64,System.Int64) +M:System.Int64.MaxMagnitude(System.Int64,System.Int64) +M:System.Int64.Min(System.Int64,System.Int64) +M:System.Int64.MinMagnitude(System.Int64,System.Int64) +M:System.Int64.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int64.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Int64.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int64.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int64.Parse(System.String) +M:System.Int64.Parse(System.String,System.Globalization.NumberStyles) +M:System.Int64.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Int64.Parse(System.String,System.IFormatProvider) +M:System.Int64.PopCount(System.Int64) +M:System.Int64.RotateLeft(System.Int64,System.Int32) +M:System.Int64.RotateRight(System.Int64,System.Int32) +M:System.Int64.Sign(System.Int64) +M:System.Int64.ToString +M:System.Int64.ToString(System.IFormatProvider) +M:System.Int64.ToString(System.String) +M:System.Int64.ToString(System.String,System.IFormatProvider) +M:System.Int64.TrailingZeroCount(System.Int64) +M:System.Int64.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int64.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) +M:System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int64@) +M:System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.Int64@) +M:System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) +M:System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int64@) +M:System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.Int64@) +M:System.Int64.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) +M:System.Int64.TryParse(System.String,System.IFormatProvider,System.Int64@) +M:System.Int64.TryParse(System.String,System.Int64@) +M:System.IntPtr.#ctor(System.Int32) +M:System.IntPtr.#ctor(System.Int64) +M:System.IntPtr.#ctor(System.Void*) +M:System.IntPtr.Abs(System.IntPtr) +M:System.IntPtr.Add(System.IntPtr,System.Int32) +M:System.IntPtr.Clamp(System.IntPtr,System.IntPtr,System.IntPtr) +M:System.IntPtr.CompareTo(System.IntPtr) +M:System.IntPtr.CompareTo(System.Object) +M:System.IntPtr.CopySign(System.IntPtr,System.IntPtr) +M:System.IntPtr.CreateChecked``1(``0) +M:System.IntPtr.CreateSaturating``1(``0) +M:System.IntPtr.CreateTruncating``1(``0) +M:System.IntPtr.DivRem(System.IntPtr,System.IntPtr) +M:System.IntPtr.Equals(System.IntPtr) +M:System.IntPtr.Equals(System.Object) +M:System.IntPtr.get_MaxValue +M:System.IntPtr.get_MinValue +M:System.IntPtr.get_Size +M:System.IntPtr.GetHashCode +M:System.IntPtr.IsEvenInteger(System.IntPtr) +M:System.IntPtr.IsNegative(System.IntPtr) +M:System.IntPtr.IsOddInteger(System.IntPtr) +M:System.IntPtr.IsPositive(System.IntPtr) +M:System.IntPtr.IsPow2(System.IntPtr) +M:System.IntPtr.LeadingZeroCount(System.IntPtr) +M:System.IntPtr.Log2(System.IntPtr) +M:System.IntPtr.Max(System.IntPtr,System.IntPtr) +M:System.IntPtr.MaxMagnitude(System.IntPtr,System.IntPtr) +M:System.IntPtr.Min(System.IntPtr,System.IntPtr) +M:System.IntPtr.MinMagnitude(System.IntPtr,System.IntPtr) +M:System.IntPtr.op_Addition(System.IntPtr,System.Int32) +M:System.IntPtr.op_Equality(System.IntPtr,System.IntPtr) +M:System.IntPtr.op_Explicit(System.Int32)~System.IntPtr +M:System.IntPtr.op_Explicit(System.Int64)~System.IntPtr +M:System.IntPtr.op_Explicit(System.IntPtr)~System.Int32 +M:System.IntPtr.op_Explicit(System.IntPtr)~System.Int64 +M:System.IntPtr.op_Explicit(System.IntPtr)~System.Void* +M:System.IntPtr.op_Explicit(System.Void*)~System.IntPtr +M:System.IntPtr.op_Inequality(System.IntPtr,System.IntPtr) +M:System.IntPtr.op_Subtraction(System.IntPtr,System.Int32) +M:System.IntPtr.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.IntPtr.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.IntPtr.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.IntPtr.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.IntPtr.Parse(System.String) +M:System.IntPtr.Parse(System.String,System.Globalization.NumberStyles) +M:System.IntPtr.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.IntPtr.Parse(System.String,System.IFormatProvider) +M:System.IntPtr.PopCount(System.IntPtr) +M:System.IntPtr.RotateLeft(System.IntPtr,System.Int32) +M:System.IntPtr.RotateRight(System.IntPtr,System.Int32) +M:System.IntPtr.Sign(System.IntPtr) +M:System.IntPtr.Subtract(System.IntPtr,System.Int32) +M:System.IntPtr.ToInt32 +M:System.IntPtr.ToInt64 +M:System.IntPtr.ToPointer +M:System.IntPtr.ToString +M:System.IntPtr.ToString(System.IFormatProvider) +M:System.IntPtr.ToString(System.String) +M:System.IntPtr.ToString(System.String,System.IFormatProvider) +M:System.IntPtr.TrailingZeroCount(System.IntPtr) +M:System.IntPtr.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.IntPtr.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) +M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.IntPtr@) +M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IntPtr@) +M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) +M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.IntPtr@) +M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IntPtr@) +M:System.IntPtr.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) +M:System.IntPtr.TryParse(System.String,System.IFormatProvider,System.IntPtr@) +M:System.IntPtr.TryParse(System.String,System.IntPtr@) +M:System.InvalidCastException.#ctor +M:System.InvalidCastException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.InvalidCastException.#ctor(System.String) +M:System.InvalidCastException.#ctor(System.String,System.Exception) +M:System.InvalidCastException.#ctor(System.String,System.Int32) +M:System.InvalidOperationException.#ctor +M:System.InvalidOperationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.InvalidOperationException.#ctor(System.String) +M:System.InvalidOperationException.#ctor(System.String,System.Exception) +M:System.InvalidProgramException.#ctor +M:System.InvalidProgramException.#ctor(System.String) +M:System.InvalidProgramException.#ctor(System.String,System.Exception) +M:System.InvalidTimeZoneException.#ctor +M:System.InvalidTimeZoneException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.InvalidTimeZoneException.#ctor(System.String) +M:System.InvalidTimeZoneException.#ctor(System.String,System.Exception) +M:System.IObservable`1.Subscribe(System.IObserver{`0}) +M:System.IObserver`1.OnCompleted +M:System.IObserver`1.OnError(System.Exception) +M:System.IObserver`1.OnNext(`0) +M:System.IParsable`1.Parse(System.String,System.IFormatProvider) +M:System.IParsable`1.TryParse(System.String,System.IFormatProvider,`0@) +M:System.IProgress`1.Report(`0) +M:System.ISpanFormattable.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.ISpanParsable`1.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.ISpanParsable`1.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,`0@) +M:System.IUtf8SpanFormattable.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.IUtf8SpanParsable`1.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.IUtf8SpanParsable`1.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,`0@) +M:System.Lazy`1.#ctor +M:System.Lazy`1.#ctor(`0) +M:System.Lazy`1.#ctor(System.Boolean) +M:System.Lazy`1.#ctor(System.Func{`0}) +M:System.Lazy`1.#ctor(System.Func{`0},System.Boolean) +M:System.Lazy`1.#ctor(System.Func{`0},System.Threading.LazyThreadSafetyMode) +M:System.Lazy`1.#ctor(System.Threading.LazyThreadSafetyMode) +M:System.Lazy`1.get_IsValueCreated +M:System.Lazy`1.get_Value +M:System.Lazy`1.ToString +M:System.Lazy`2.#ctor(`1) +M:System.Lazy`2.#ctor(`1,System.Boolean) +M:System.Lazy`2.#ctor(`1,System.Threading.LazyThreadSafetyMode) +M:System.Lazy`2.#ctor(System.Func{`0},`1) +M:System.Lazy`2.#ctor(System.Func{`0},`1,System.Boolean) +M:System.Lazy`2.#ctor(System.Func{`0},`1,System.Threading.LazyThreadSafetyMode) +M:System.Lazy`2.get_Metadata +M:System.LdapStyleUriParser.#ctor +M:System.Math.Abs(System.Decimal) +M:System.Math.Abs(System.Double) +M:System.Math.Abs(System.Int16) +M:System.Math.Abs(System.Int32) +M:System.Math.Abs(System.Int64) +M:System.Math.Abs(System.IntPtr) +M:System.Math.Abs(System.SByte) +M:System.Math.Abs(System.Single) +M:System.Math.Acos(System.Double) +M:System.Math.Acosh(System.Double) +M:System.Math.Asin(System.Double) +M:System.Math.Asinh(System.Double) +M:System.Math.Atan(System.Double) +M:System.Math.Atan2(System.Double,System.Double) +M:System.Math.Atanh(System.Double) +M:System.Math.BigMul(System.Int32,System.Int32) +M:System.Math.BigMul(System.Int64,System.Int64,System.Int64@) +M:System.Math.BigMul(System.UInt64,System.UInt64,System.UInt64@) +M:System.Math.BitDecrement(System.Double) +M:System.Math.BitIncrement(System.Double) +M:System.Math.Cbrt(System.Double) +M:System.Math.Ceiling(System.Decimal) +M:System.Math.Ceiling(System.Double) +M:System.Math.Clamp(System.Byte,System.Byte,System.Byte) +M:System.Math.Clamp(System.Decimal,System.Decimal,System.Decimal) +M:System.Math.Clamp(System.Double,System.Double,System.Double) +M:System.Math.Clamp(System.Int16,System.Int16,System.Int16) +M:System.Math.Clamp(System.Int32,System.Int32,System.Int32) +M:System.Math.Clamp(System.Int64,System.Int64,System.Int64) +M:System.Math.Clamp(System.IntPtr,System.IntPtr,System.IntPtr) +M:System.Math.Clamp(System.SByte,System.SByte,System.SByte) +M:System.Math.Clamp(System.Single,System.Single,System.Single) +M:System.Math.Clamp(System.UInt16,System.UInt16,System.UInt16) +M:System.Math.Clamp(System.UInt32,System.UInt32,System.UInt32) +M:System.Math.Clamp(System.UInt64,System.UInt64,System.UInt64) +M:System.Math.Clamp(System.UIntPtr,System.UIntPtr,System.UIntPtr) +M:System.Math.CopySign(System.Double,System.Double) +M:System.Math.Cos(System.Double) +M:System.Math.Cosh(System.Double) +M:System.Math.DivRem(System.Byte,System.Byte) +M:System.Math.DivRem(System.Int16,System.Int16) +M:System.Math.DivRem(System.Int32,System.Int32) +M:System.Math.DivRem(System.Int32,System.Int32,System.Int32@) +M:System.Math.DivRem(System.Int64,System.Int64) +M:System.Math.DivRem(System.Int64,System.Int64,System.Int64@) +M:System.Math.DivRem(System.IntPtr,System.IntPtr) +M:System.Math.DivRem(System.SByte,System.SByte) +M:System.Math.DivRem(System.UInt16,System.UInt16) +M:System.Math.DivRem(System.UInt32,System.UInt32) +M:System.Math.DivRem(System.UInt64,System.UInt64) +M:System.Math.DivRem(System.UIntPtr,System.UIntPtr) +M:System.Math.Exp(System.Double) +M:System.Math.Floor(System.Decimal) +M:System.Math.Floor(System.Double) +M:System.Math.FusedMultiplyAdd(System.Double,System.Double,System.Double) +M:System.Math.IEEERemainder(System.Double,System.Double) +M:System.Math.ILogB(System.Double) +M:System.Math.Log(System.Double) +M:System.Math.Log(System.Double,System.Double) +M:System.Math.Log10(System.Double) +M:System.Math.Log2(System.Double) +M:System.Math.Max(System.Byte,System.Byte) +M:System.Math.Max(System.Decimal,System.Decimal) +M:System.Math.Max(System.Double,System.Double) +M:System.Math.Max(System.Int16,System.Int16) +M:System.Math.Max(System.Int32,System.Int32) +M:System.Math.Max(System.Int64,System.Int64) +M:System.Math.Max(System.IntPtr,System.IntPtr) +M:System.Math.Max(System.SByte,System.SByte) +M:System.Math.Max(System.Single,System.Single) +M:System.Math.Max(System.UInt16,System.UInt16) +M:System.Math.Max(System.UInt32,System.UInt32) +M:System.Math.Max(System.UInt64,System.UInt64) +M:System.Math.Max(System.UIntPtr,System.UIntPtr) +M:System.Math.MaxMagnitude(System.Double,System.Double) +M:System.Math.Min(System.Byte,System.Byte) +M:System.Math.Min(System.Decimal,System.Decimal) +M:System.Math.Min(System.Double,System.Double) +M:System.Math.Min(System.Int16,System.Int16) +M:System.Math.Min(System.Int32,System.Int32) +M:System.Math.Min(System.Int64,System.Int64) +M:System.Math.Min(System.IntPtr,System.IntPtr) +M:System.Math.Min(System.SByte,System.SByte) +M:System.Math.Min(System.Single,System.Single) +M:System.Math.Min(System.UInt16,System.UInt16) +M:System.Math.Min(System.UInt32,System.UInt32) +M:System.Math.Min(System.UInt64,System.UInt64) +M:System.Math.Min(System.UIntPtr,System.UIntPtr) +M:System.Math.MinMagnitude(System.Double,System.Double) +M:System.Math.Pow(System.Double,System.Double) +M:System.Math.ReciprocalEstimate(System.Double) +M:System.Math.ReciprocalSqrtEstimate(System.Double) +M:System.Math.Round(System.Decimal) +M:System.Math.Round(System.Decimal,System.Int32) +M:System.Math.Round(System.Decimal,System.Int32,System.MidpointRounding) +M:System.Math.Round(System.Decimal,System.MidpointRounding) +M:System.Math.Round(System.Double) +M:System.Math.Round(System.Double,System.Int32) +M:System.Math.Round(System.Double,System.Int32,System.MidpointRounding) +M:System.Math.Round(System.Double,System.MidpointRounding) +M:System.Math.ScaleB(System.Double,System.Int32) +M:System.Math.Sign(System.Decimal) +M:System.Math.Sign(System.Double) +M:System.Math.Sign(System.Int16) +M:System.Math.Sign(System.Int32) +M:System.Math.Sign(System.Int64) +M:System.Math.Sign(System.IntPtr) +M:System.Math.Sign(System.SByte) +M:System.Math.Sign(System.Single) +M:System.Math.Sin(System.Double) +M:System.Math.SinCos(System.Double) +M:System.Math.Sinh(System.Double) +M:System.Math.Sqrt(System.Double) +M:System.Math.Tan(System.Double) +M:System.Math.Tanh(System.Double) +M:System.Math.Truncate(System.Decimal) +M:System.Math.Truncate(System.Double) +M:System.MathF.Abs(System.Single) +M:System.MathF.Acos(System.Single) +M:System.MathF.Acosh(System.Single) +M:System.MathF.Asin(System.Single) +M:System.MathF.Asinh(System.Single) +M:System.MathF.Atan(System.Single) +M:System.MathF.Atan2(System.Single,System.Single) +M:System.MathF.Atanh(System.Single) +M:System.MathF.BitDecrement(System.Single) +M:System.MathF.BitIncrement(System.Single) +M:System.MathF.Cbrt(System.Single) +M:System.MathF.Ceiling(System.Single) +M:System.MathF.CopySign(System.Single,System.Single) +M:System.MathF.Cos(System.Single) +M:System.MathF.Cosh(System.Single) +M:System.MathF.Exp(System.Single) +M:System.MathF.Floor(System.Single) +M:System.MathF.FusedMultiplyAdd(System.Single,System.Single,System.Single) +M:System.MathF.IEEERemainder(System.Single,System.Single) +M:System.MathF.ILogB(System.Single) +M:System.MathF.Log(System.Single) +M:System.MathF.Log(System.Single,System.Single) +M:System.MathF.Log10(System.Single) +M:System.MathF.Log2(System.Single) +M:System.MathF.Max(System.Single,System.Single) +M:System.MathF.MaxMagnitude(System.Single,System.Single) +M:System.MathF.Min(System.Single,System.Single) +M:System.MathF.MinMagnitude(System.Single,System.Single) +M:System.MathF.Pow(System.Single,System.Single) +M:System.MathF.ReciprocalEstimate(System.Single) +M:System.MathF.ReciprocalSqrtEstimate(System.Single) +M:System.MathF.Round(System.Single) +M:System.MathF.Round(System.Single,System.Int32) +M:System.MathF.Round(System.Single,System.Int32,System.MidpointRounding) +M:System.MathF.Round(System.Single,System.MidpointRounding) +M:System.MathF.ScaleB(System.Single,System.Int32) +M:System.MathF.Sign(System.Single) +M:System.MathF.Sin(System.Single) +M:System.MathF.SinCos(System.Single) +M:System.MathF.Sinh(System.Single) +M:System.MathF.Sqrt(System.Single) +M:System.MathF.Tan(System.Single) +M:System.MathF.Tanh(System.Single) +M:System.MathF.Truncate(System.Single) +M:System.MemberAccessException.#ctor +M:System.MemberAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MemberAccessException.#ctor(System.String) +M:System.MemberAccessException.#ctor(System.String,System.Exception) +M:System.Memory`1.#ctor(`0[]) +M:System.Memory`1.#ctor(`0[],System.Int32,System.Int32) +M:System.Memory`1.CopyTo(System.Memory{`0}) +M:System.Memory`1.Equals(System.Memory{`0}) +M:System.Memory`1.Equals(System.Object) +M:System.Memory`1.get_Empty +M:System.Memory`1.get_IsEmpty +M:System.Memory`1.get_Length +M:System.Memory`1.get_Span +M:System.Memory`1.GetHashCode +M:System.Memory`1.op_Implicit(`0[])~System.Memory{`0} +M:System.Memory`1.op_Implicit(System.ArraySegment{`0})~System.Memory{`0} +M:System.Memory`1.op_Implicit(System.Memory{`0})~System.ReadOnlyMemory{`0} +M:System.Memory`1.Pin +M:System.Memory`1.Slice(System.Int32) +M:System.Memory`1.Slice(System.Int32,System.Int32) +M:System.Memory`1.ToArray +M:System.Memory`1.ToString +M:System.Memory`1.TryCopyTo(System.Memory{`0}) +M:System.MethodAccessException.#ctor +M:System.MethodAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MethodAccessException.#ctor(System.String) +M:System.MethodAccessException.#ctor(System.String,System.Exception) +M:System.MissingFieldException.#ctor +M:System.MissingFieldException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MissingFieldException.#ctor(System.String) +M:System.MissingFieldException.#ctor(System.String,System.Exception) +M:System.MissingFieldException.#ctor(System.String,System.String) +M:System.MissingFieldException.get_Message +M:System.MissingMemberException.#ctor +M:System.MissingMemberException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MissingMemberException.#ctor(System.String) +M:System.MissingMemberException.#ctor(System.String,System.Exception) +M:System.MissingMemberException.#ctor(System.String,System.String) +M:System.MissingMemberException.get_Message +M:System.MissingMemberException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MissingMethodException.#ctor +M:System.MissingMethodException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MissingMethodException.#ctor(System.String) +M:System.MissingMethodException.#ctor(System.String,System.Exception) +M:System.MissingMethodException.#ctor(System.String,System.String) +M:System.MissingMethodException.get_Message +M:System.ModuleHandle.Equals(System.ModuleHandle) +M:System.ModuleHandle.Equals(System.Object) +M:System.ModuleHandle.get_MDStreamVersion +M:System.ModuleHandle.GetHashCode +M:System.ModuleHandle.GetRuntimeFieldHandleFromMetadataToken(System.Int32) +M:System.ModuleHandle.GetRuntimeMethodHandleFromMetadataToken(System.Int32) +M:System.ModuleHandle.GetRuntimeTypeHandleFromMetadataToken(System.Int32) +M:System.ModuleHandle.op_Equality(System.ModuleHandle,System.ModuleHandle) +M:System.ModuleHandle.op_Inequality(System.ModuleHandle,System.ModuleHandle) +M:System.ModuleHandle.ResolveFieldHandle(System.Int32) +M:System.ModuleHandle.ResolveFieldHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[]) +M:System.ModuleHandle.ResolveMethodHandle(System.Int32) +M:System.ModuleHandle.ResolveMethodHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[]) +M:System.ModuleHandle.ResolveTypeHandle(System.Int32) +M:System.ModuleHandle.ResolveTypeHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[]) +M:System.MulticastDelegate.#ctor(System.Object,System.String) +M:System.MulticastDelegate.#ctor(System.Type,System.String) +M:System.MulticastDelegate.CombineImpl(System.Delegate) +M:System.MulticastDelegate.Equals(System.Object) +M:System.MulticastDelegate.GetHashCode +M:System.MulticastDelegate.GetInvocationList +M:System.MulticastDelegate.GetMethodImpl +M:System.MulticastDelegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.MulticastDelegate.op_Equality(System.MulticastDelegate,System.MulticastDelegate) +M:System.MulticastDelegate.op_Inequality(System.MulticastDelegate,System.MulticastDelegate) +M:System.MulticastDelegate.RemoveImpl(System.Delegate) +M:System.MulticastNotSupportedException.#ctor +M:System.MulticastNotSupportedException.#ctor(System.String) +M:System.MulticastNotSupportedException.#ctor(System.String,System.Exception) +M:System.NetPipeStyleUriParser.#ctor +M:System.NetTcpStyleUriParser.#ctor +M:System.NewsStyleUriParser.#ctor +M:System.NonSerializedAttribute.#ctor +M:System.NotFiniteNumberException.#ctor +M:System.NotFiniteNumberException.#ctor(System.Double) +M:System.NotFiniteNumberException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.NotFiniteNumberException.#ctor(System.String) +M:System.NotFiniteNumberException.#ctor(System.String,System.Double) +M:System.NotFiniteNumberException.#ctor(System.String,System.Double,System.Exception) +M:System.NotFiniteNumberException.#ctor(System.String,System.Exception) +M:System.NotFiniteNumberException.get_OffendingNumber +M:System.NotFiniteNumberException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.NotImplementedException.#ctor +M:System.NotImplementedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.NotImplementedException.#ctor(System.String) +M:System.NotImplementedException.#ctor(System.String,System.Exception) +M:System.NotSupportedException.#ctor +M:System.NotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.NotSupportedException.#ctor(System.String) +M:System.NotSupportedException.#ctor(System.String,System.Exception) +M:System.Nullable.Compare``1(System.Nullable{``0},System.Nullable{``0}) +M:System.Nullable.Equals``1(System.Nullable{``0},System.Nullable{``0}) +M:System.Nullable.GetUnderlyingType(System.Type) +M:System.Nullable.GetValueRefOrDefaultRef``1(System.Nullable{``0}@) +M:System.Nullable`1.#ctor(`0) +M:System.Nullable`1.Equals(System.Object) +M:System.Nullable`1.get_HasValue +M:System.Nullable`1.get_Value +M:System.Nullable`1.GetHashCode +M:System.Nullable`1.GetValueOrDefault +M:System.Nullable`1.GetValueOrDefault(`0) +M:System.Nullable`1.op_Explicit(System.Nullable{`0})~`0 +M:System.Nullable`1.op_Implicit(`0)~System.Nullable{`0} +M:System.Nullable`1.ToString +M:System.NullReferenceException.#ctor +M:System.NullReferenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.NullReferenceException.#ctor(System.String) +M:System.NullReferenceException.#ctor(System.String,System.Exception) +M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.Byte) +M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt16) +M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt32) +M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt64) +M:System.Numerics.BitOperations.IsPow2(System.Int32) +M:System.Numerics.BitOperations.IsPow2(System.Int64) +M:System.Numerics.BitOperations.IsPow2(System.IntPtr) +M:System.Numerics.BitOperations.IsPow2(System.UInt32) +M:System.Numerics.BitOperations.IsPow2(System.UInt64) +M:System.Numerics.BitOperations.IsPow2(System.UIntPtr) +M:System.Numerics.BitOperations.LeadingZeroCount(System.UInt32) +M:System.Numerics.BitOperations.LeadingZeroCount(System.UInt64) +M:System.Numerics.BitOperations.LeadingZeroCount(System.UIntPtr) +M:System.Numerics.BitOperations.Log2(System.UInt32) +M:System.Numerics.BitOperations.Log2(System.UInt64) +M:System.Numerics.BitOperations.Log2(System.UIntPtr) +M:System.Numerics.BitOperations.PopCount(System.UInt32) +M:System.Numerics.BitOperations.PopCount(System.UInt64) +M:System.Numerics.BitOperations.PopCount(System.UIntPtr) +M:System.Numerics.BitOperations.RotateLeft(System.UInt32,System.Int32) +M:System.Numerics.BitOperations.RotateLeft(System.UInt64,System.Int32) +M:System.Numerics.BitOperations.RotateLeft(System.UIntPtr,System.Int32) +M:System.Numerics.BitOperations.RotateRight(System.UInt32,System.Int32) +M:System.Numerics.BitOperations.RotateRight(System.UInt64,System.Int32) +M:System.Numerics.BitOperations.RotateRight(System.UIntPtr,System.Int32) +M:System.Numerics.BitOperations.RoundUpToPowerOf2(System.UInt32) +M:System.Numerics.BitOperations.RoundUpToPowerOf2(System.UInt64) +M:System.Numerics.BitOperations.RoundUpToPowerOf2(System.UIntPtr) +M:System.Numerics.BitOperations.TrailingZeroCount(System.Int32) +M:System.Numerics.BitOperations.TrailingZeroCount(System.Int64) +M:System.Numerics.BitOperations.TrailingZeroCount(System.IntPtr) +M:System.Numerics.BitOperations.TrailingZeroCount(System.UInt32) +M:System.Numerics.BitOperations.TrailingZeroCount(System.UInt64) +M:System.Numerics.BitOperations.TrailingZeroCount(System.UIntPtr) +M:System.Numerics.IAdditionOperators`3.op_Addition(`0,`1) +M:System.Numerics.IAdditionOperators`3.op_CheckedAddition(`0,`1) +M:System.Numerics.IAdditiveIdentity`2.get_AdditiveIdentity +M:System.Numerics.IBinaryInteger`1.DivRem(`0,`0) +M:System.Numerics.IBinaryInteger`1.GetByteCount +M:System.Numerics.IBinaryInteger`1.GetShortestBitLength +M:System.Numerics.IBinaryInteger`1.LeadingZeroCount(`0) +M:System.Numerics.IBinaryInteger`1.PopCount(`0) +M:System.Numerics.IBinaryInteger`1.ReadBigEndian(System.Byte[],System.Boolean) +M:System.Numerics.IBinaryInteger`1.ReadBigEndian(System.Byte[],System.Int32,System.Boolean) +M:System.Numerics.IBinaryInteger`1.ReadBigEndian(System.ReadOnlySpan{System.Byte},System.Boolean) +M:System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.Byte[],System.Boolean) +M:System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.Byte[],System.Int32,System.Boolean) +M:System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.ReadOnlySpan{System.Byte},System.Boolean) +M:System.Numerics.IBinaryInteger`1.RotateLeft(`0,System.Int32) +M:System.Numerics.IBinaryInteger`1.RotateRight(`0,System.Int32) +M:System.Numerics.IBinaryInteger`1.TrailingZeroCount(`0) +M:System.Numerics.IBinaryInteger`1.TryReadBigEndian(System.ReadOnlySpan{System.Byte},System.Boolean,`0@) +M:System.Numerics.IBinaryInteger`1.TryReadLittleEndian(System.ReadOnlySpan{System.Byte},System.Boolean,`0@) +M:System.Numerics.IBinaryInteger`1.TryWriteBigEndian(System.Span{System.Byte},System.Int32@) +M:System.Numerics.IBinaryInteger`1.TryWriteLittleEndian(System.Span{System.Byte},System.Int32@) +M:System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Byte[]) +M:System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Byte[],System.Int32) +M:System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Span{System.Byte}) +M:System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Byte[]) +M:System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Byte[],System.Int32) +M:System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Span{System.Byte}) +M:System.Numerics.IBinaryNumber`1.get_AllBitsSet +M:System.Numerics.IBinaryNumber`1.IsPow2(`0) +M:System.Numerics.IBinaryNumber`1.Log2(`0) +M:System.Numerics.IBitwiseOperators`3.op_BitwiseAnd(`0,`1) +M:System.Numerics.IBitwiseOperators`3.op_BitwiseOr(`0,`1) +M:System.Numerics.IBitwiseOperators`3.op_ExclusiveOr(`0,`1) +M:System.Numerics.IBitwiseOperators`3.op_OnesComplement(`0) +M:System.Numerics.IComparisonOperators`3.op_GreaterThan(`0,`1) +M:System.Numerics.IComparisonOperators`3.op_GreaterThanOrEqual(`0,`1) +M:System.Numerics.IComparisonOperators`3.op_LessThan(`0,`1) +M:System.Numerics.IComparisonOperators`3.op_LessThanOrEqual(`0,`1) +M:System.Numerics.IDecrementOperators`1.op_CheckedDecrement(`0) +M:System.Numerics.IDecrementOperators`1.op_Decrement(`0) +M:System.Numerics.IDivisionOperators`3.op_CheckedDivision(`0,`1) +M:System.Numerics.IDivisionOperators`3.op_Division(`0,`1) +M:System.Numerics.IEqualityOperators`3.op_Equality(`0,`1) +M:System.Numerics.IEqualityOperators`3.op_Inequality(`0,`1) +M:System.Numerics.IExponentialFunctions`1.Exp(`0) +M:System.Numerics.IExponentialFunctions`1.Exp10(`0) +M:System.Numerics.IExponentialFunctions`1.Exp10M1(`0) +M:System.Numerics.IExponentialFunctions`1.Exp2(`0) +M:System.Numerics.IExponentialFunctions`1.Exp2M1(`0) +M:System.Numerics.IExponentialFunctions`1.ExpM1(`0) +M:System.Numerics.IFloatingPoint`1.Ceiling(`0) +M:System.Numerics.IFloatingPoint`1.Floor(`0) +M:System.Numerics.IFloatingPoint`1.GetExponentByteCount +M:System.Numerics.IFloatingPoint`1.GetExponentShortestBitLength +M:System.Numerics.IFloatingPoint`1.GetSignificandBitLength +M:System.Numerics.IFloatingPoint`1.GetSignificandByteCount +M:System.Numerics.IFloatingPoint`1.Round(`0) +M:System.Numerics.IFloatingPoint`1.Round(`0,System.Int32) +M:System.Numerics.IFloatingPoint`1.Round(`0,System.Int32,System.MidpointRounding) +M:System.Numerics.IFloatingPoint`1.Round(`0,System.MidpointRounding) +M:System.Numerics.IFloatingPoint`1.Truncate(`0) +M:System.Numerics.IFloatingPoint`1.TryWriteExponentBigEndian(System.Span{System.Byte},System.Int32@) +M:System.Numerics.IFloatingPoint`1.TryWriteExponentLittleEndian(System.Span{System.Byte},System.Int32@) +M:System.Numerics.IFloatingPoint`1.TryWriteSignificandBigEndian(System.Span{System.Byte},System.Int32@) +M:System.Numerics.IFloatingPoint`1.TryWriteSignificandLittleEndian(System.Span{System.Byte},System.Int32@) +M:System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Byte[]) +M:System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Byte[],System.Int32) +M:System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Span{System.Byte}) +M:System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Byte[]) +M:System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Byte[],System.Int32) +M:System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Span{System.Byte}) +M:System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Byte[]) +M:System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Byte[],System.Int32) +M:System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Span{System.Byte}) +M:System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Byte[]) +M:System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Byte[],System.Int32) +M:System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Span{System.Byte}) +M:System.Numerics.IFloatingPointConstants`1.get_E +M:System.Numerics.IFloatingPointConstants`1.get_Pi +M:System.Numerics.IFloatingPointConstants`1.get_Tau +M:System.Numerics.IFloatingPointIeee754`1.Atan2(`0,`0) +M:System.Numerics.IFloatingPointIeee754`1.Atan2Pi(`0,`0) +M:System.Numerics.IFloatingPointIeee754`1.BitDecrement(`0) +M:System.Numerics.IFloatingPointIeee754`1.BitIncrement(`0) +M:System.Numerics.IFloatingPointIeee754`1.FusedMultiplyAdd(`0,`0,`0) +M:System.Numerics.IFloatingPointIeee754`1.get_Epsilon +M:System.Numerics.IFloatingPointIeee754`1.get_NaN +M:System.Numerics.IFloatingPointIeee754`1.get_NegativeInfinity +M:System.Numerics.IFloatingPointIeee754`1.get_NegativeZero +M:System.Numerics.IFloatingPointIeee754`1.get_PositiveInfinity +M:System.Numerics.IFloatingPointIeee754`1.Ieee754Remainder(`0,`0) +M:System.Numerics.IFloatingPointIeee754`1.ILogB(`0) +M:System.Numerics.IFloatingPointIeee754`1.Lerp(`0,`0,`0) +M:System.Numerics.IFloatingPointIeee754`1.ReciprocalEstimate(`0) +M:System.Numerics.IFloatingPointIeee754`1.ReciprocalSqrtEstimate(`0) +M:System.Numerics.IFloatingPointIeee754`1.ScaleB(`0,System.Int32) +M:System.Numerics.IHyperbolicFunctions`1.Acosh(`0) +M:System.Numerics.IHyperbolicFunctions`1.Asinh(`0) +M:System.Numerics.IHyperbolicFunctions`1.Atanh(`0) +M:System.Numerics.IHyperbolicFunctions`1.Cosh(`0) +M:System.Numerics.IHyperbolicFunctions`1.Sinh(`0) +M:System.Numerics.IHyperbolicFunctions`1.Tanh(`0) +M:System.Numerics.IIncrementOperators`1.op_CheckedIncrement(`0) +M:System.Numerics.IIncrementOperators`1.op_Increment(`0) +M:System.Numerics.ILogarithmicFunctions`1.Log(`0) +M:System.Numerics.ILogarithmicFunctions`1.Log(`0,`0) +M:System.Numerics.ILogarithmicFunctions`1.Log10(`0) +M:System.Numerics.ILogarithmicFunctions`1.Log10P1(`0) +M:System.Numerics.ILogarithmicFunctions`1.Log2(`0) +M:System.Numerics.ILogarithmicFunctions`1.Log2P1(`0) +M:System.Numerics.ILogarithmicFunctions`1.LogP1(`0) +M:System.Numerics.IMinMaxValue`1.get_MaxValue +M:System.Numerics.IMinMaxValue`1.get_MinValue +M:System.Numerics.IModulusOperators`3.op_Modulus(`0,`1) +M:System.Numerics.IMultiplicativeIdentity`2.get_MultiplicativeIdentity +M:System.Numerics.IMultiplyOperators`3.op_CheckedMultiply(`0,`1) +M:System.Numerics.IMultiplyOperators`3.op_Multiply(`0,`1) +M:System.Numerics.INumber`1.Clamp(`0,`0,`0) +M:System.Numerics.INumber`1.CopySign(`0,`0) +M:System.Numerics.INumber`1.Max(`0,`0) +M:System.Numerics.INumber`1.MaxNumber(`0,`0) +M:System.Numerics.INumber`1.Min(`0,`0) +M:System.Numerics.INumber`1.MinNumber(`0,`0) +M:System.Numerics.INumber`1.Sign(`0) +M:System.Numerics.INumberBase`1.Abs(`0) +M:System.Numerics.INumberBase`1.CreateChecked``1(``0) +M:System.Numerics.INumberBase`1.CreateSaturating``1(``0) +M:System.Numerics.INumberBase`1.CreateTruncating``1(``0) +M:System.Numerics.INumberBase`1.get_One +M:System.Numerics.INumberBase`1.get_Radix +M:System.Numerics.INumberBase`1.get_Zero +M:System.Numerics.INumberBase`1.IsCanonical(`0) +M:System.Numerics.INumberBase`1.IsComplexNumber(`0) +M:System.Numerics.INumberBase`1.IsEvenInteger(`0) +M:System.Numerics.INumberBase`1.IsFinite(`0) +M:System.Numerics.INumberBase`1.IsImaginaryNumber(`0) +M:System.Numerics.INumberBase`1.IsInfinity(`0) +M:System.Numerics.INumberBase`1.IsInteger(`0) +M:System.Numerics.INumberBase`1.IsNaN(`0) +M:System.Numerics.INumberBase`1.IsNegative(`0) +M:System.Numerics.INumberBase`1.IsNegativeInfinity(`0) +M:System.Numerics.INumberBase`1.IsNormal(`0) +M:System.Numerics.INumberBase`1.IsOddInteger(`0) +M:System.Numerics.INumberBase`1.IsPositive(`0) +M:System.Numerics.INumberBase`1.IsPositiveInfinity(`0) +M:System.Numerics.INumberBase`1.IsRealNumber(`0) +M:System.Numerics.INumberBase`1.IsSubnormal(`0) +M:System.Numerics.INumberBase`1.IsZero(`0) +M:System.Numerics.INumberBase`1.MaxMagnitude(`0,`0) +M:System.Numerics.INumberBase`1.MaxMagnitudeNumber(`0,`0) +M:System.Numerics.INumberBase`1.MinMagnitude(`0,`0) +M:System.Numerics.INumberBase`1.MinMagnitudeNumber(`0,`0) +M:System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Numerics.INumberBase`1.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Numerics.INumberBase`1.TryConvertFromChecked``1(``0,`0@) +M:System.Numerics.INumberBase`1.TryConvertFromSaturating``1(``0,`0@) +M:System.Numerics.INumberBase`1.TryConvertFromTruncating``1(``0,`0@) +M:System.Numerics.INumberBase`1.TryConvertToChecked``1(`0,``0@) +M:System.Numerics.INumberBase`1.TryConvertToSaturating``1(`0,``0@) +M:System.Numerics.INumberBase`1.TryConvertToTruncating``1(`0,``0@) +M:System.Numerics.INumberBase`1.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,`0@) +M:System.Numerics.INumberBase`1.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,`0@) +M:System.Numerics.INumberBase`1.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,`0@) +M:System.Numerics.IPowerFunctions`1.Pow(`0,`0) +M:System.Numerics.IRootFunctions`1.Cbrt(`0) +M:System.Numerics.IRootFunctions`1.Hypot(`0,`0) +M:System.Numerics.IRootFunctions`1.RootN(`0,System.Int32) +M:System.Numerics.IRootFunctions`1.Sqrt(`0) +M:System.Numerics.IShiftOperators`3.op_LeftShift(`0,`1) +M:System.Numerics.IShiftOperators`3.op_RightShift(`0,`1) +M:System.Numerics.IShiftOperators`3.op_UnsignedRightShift(`0,`1) +M:System.Numerics.ISignedNumber`1.get_NegativeOne +M:System.Numerics.ISubtractionOperators`3.op_CheckedSubtraction(`0,`1) +M:System.Numerics.ISubtractionOperators`3.op_Subtraction(`0,`1) +M:System.Numerics.ITrigonometricFunctions`1.Acos(`0) +M:System.Numerics.ITrigonometricFunctions`1.AcosPi(`0) +M:System.Numerics.ITrigonometricFunctions`1.Asin(`0) +M:System.Numerics.ITrigonometricFunctions`1.AsinPi(`0) +M:System.Numerics.ITrigonometricFunctions`1.Atan(`0) +M:System.Numerics.ITrigonometricFunctions`1.AtanPi(`0) +M:System.Numerics.ITrigonometricFunctions`1.Cos(`0) +M:System.Numerics.ITrigonometricFunctions`1.CosPi(`0) +M:System.Numerics.ITrigonometricFunctions`1.DegreesToRadians(`0) +M:System.Numerics.ITrigonometricFunctions`1.RadiansToDegrees(`0) +M:System.Numerics.ITrigonometricFunctions`1.Sin(`0) +M:System.Numerics.ITrigonometricFunctions`1.SinCos(`0) +M:System.Numerics.ITrigonometricFunctions`1.SinCosPi(`0) +M:System.Numerics.ITrigonometricFunctions`1.SinPi(`0) +M:System.Numerics.ITrigonometricFunctions`1.Tan(`0) +M:System.Numerics.ITrigonometricFunctions`1.TanPi(`0) +M:System.Numerics.IUnaryNegationOperators`2.op_CheckedUnaryNegation(`0) +M:System.Numerics.IUnaryNegationOperators`2.op_UnaryNegation(`0) +M:System.Numerics.IUnaryPlusOperators`2.op_UnaryPlus(`0) +M:System.Numerics.TotalOrderIeee754Comparer`1.Compare(`0,`0) +M:System.Numerics.TotalOrderIeee754Comparer`1.Equals(`0,`0) +M:System.Numerics.TotalOrderIeee754Comparer`1.Equals(System.Numerics.TotalOrderIeee754Comparer{`0}) +M:System.Numerics.TotalOrderIeee754Comparer`1.Equals(System.Object) +M:System.Numerics.TotalOrderIeee754Comparer`1.GetHashCode +M:System.Numerics.TotalOrderIeee754Comparer`1.GetHashCode(`0) +M:System.Object.#ctor +M:System.Object.Equals(System.Object) +M:System.Object.Equals(System.Object,System.Object) +M:System.Object.Finalize +M:System.Object.GetHashCode +M:System.Object.GetType +M:System.Object.MemberwiseClone +M:System.Object.ReferenceEquals(System.Object,System.Object) +M:System.Object.ToString +M:System.ObjectDisposedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ObjectDisposedException.#ctor(System.String) +M:System.ObjectDisposedException.#ctor(System.String,System.Exception) +M:System.ObjectDisposedException.#ctor(System.String,System.String) +M:System.ObjectDisposedException.get_Message +M:System.ObjectDisposedException.get_ObjectName +M:System.ObjectDisposedException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.ObjectDisposedException.ThrowIf(System.Boolean,System.Object) +M:System.ObjectDisposedException.ThrowIf(System.Boolean,System.Type) +M:System.ObsoleteAttribute.#ctor +M:System.ObsoleteAttribute.#ctor(System.String) +M:System.ObsoleteAttribute.#ctor(System.String,System.Boolean) +M:System.ObsoleteAttribute.get_DiagnosticId +M:System.ObsoleteAttribute.get_IsError +M:System.ObsoleteAttribute.get_Message +M:System.ObsoleteAttribute.get_UrlFormat +M:System.ObsoleteAttribute.set_DiagnosticId(System.String) +M:System.ObsoleteAttribute.set_UrlFormat(System.String) +M:System.OperatingSystem.#ctor(System.PlatformID,System.Version) +M:System.OperatingSystem.Clone +M:System.OperatingSystem.get_Platform +M:System.OperatingSystem.get_ServicePack +M:System.OperatingSystem.get_Version +M:System.OperatingSystem.get_VersionString +M:System.OperatingSystem.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.OperatingSystem.IsAndroid +M:System.OperatingSystem.IsAndroidVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsBrowser +M:System.OperatingSystem.IsFreeBSD +M:System.OperatingSystem.IsFreeBSDVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsIOS +M:System.OperatingSystem.IsIOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsLinux +M:System.OperatingSystem.IsMacCatalyst +M:System.OperatingSystem.IsMacCatalystVersionAtLeast(System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsMacOS +M:System.OperatingSystem.IsMacOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsOSPlatform(System.String) +M:System.OperatingSystem.IsOSPlatformVersionAtLeast(System.String,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsTvOS +M:System.OperatingSystem.IsTvOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsWasi +M:System.OperatingSystem.IsWatchOS +M:System.OperatingSystem.IsWatchOSVersionAtLeast(System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.IsWindows +M:System.OperatingSystem.IsWindowsVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.OperatingSystem.ToString +M:System.OperationCanceledException.#ctor +M:System.OperationCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.OperationCanceledException.#ctor(System.String) +M:System.OperationCanceledException.#ctor(System.String,System.Exception) +M:System.OperationCanceledException.#ctor(System.String,System.Exception,System.Threading.CancellationToken) +M:System.OperationCanceledException.#ctor(System.String,System.Threading.CancellationToken) +M:System.OperationCanceledException.#ctor(System.Threading.CancellationToken) +M:System.OperationCanceledException.get_CancellationToken +M:System.OutOfMemoryException.#ctor +M:System.OutOfMemoryException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.OutOfMemoryException.#ctor(System.String) +M:System.OutOfMemoryException.#ctor(System.String,System.Exception) +M:System.OverflowException.#ctor +M:System.OverflowException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.OverflowException.#ctor(System.String) +M:System.OverflowException.#ctor(System.String,System.Exception) +M:System.ParamArrayAttribute.#ctor +M:System.PlatformNotSupportedException.#ctor +M:System.PlatformNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.PlatformNotSupportedException.#ctor(System.String) +M:System.PlatformNotSupportedException.#ctor(System.String,System.Exception) +M:System.Predicate`1.#ctor(System.Object,System.IntPtr) +M:System.Predicate`1.BeginInvoke(`0,System.AsyncCallback,System.Object) +M:System.Predicate`1.EndInvoke(System.IAsyncResult) +M:System.Predicate`1.Invoke(`0) +M:System.Progress`1.#ctor +M:System.Progress`1.#ctor(System.Action{`0}) +M:System.Progress`1.add_ProgressChanged(System.EventHandler{`0}) +M:System.Progress`1.OnReport(`0) +M:System.Progress`1.remove_ProgressChanged(System.EventHandler{`0}) +M:System.Random.#ctor +M:System.Random.#ctor(System.Int32) +M:System.Random.get_Shared +M:System.Random.GetItems``1(``0[],System.Int32) +M:System.Random.GetItems``1(System.ReadOnlySpan{``0},System.Int32) +M:System.Random.GetItems``1(System.ReadOnlySpan{``0},System.Span{``0}) +M:System.Random.Next +M:System.Random.Next(System.Int32) +M:System.Random.Next(System.Int32,System.Int32) +M:System.Random.NextBytes(System.Byte[]) +M:System.Random.NextBytes(System.Span{System.Byte}) +M:System.Random.NextDouble +M:System.Random.NextInt64 +M:System.Random.NextInt64(System.Int64) +M:System.Random.NextInt64(System.Int64,System.Int64) +M:System.Random.NextSingle +M:System.Random.Sample +M:System.Random.Shuffle``1(``0[]) +M:System.Random.Shuffle``1(System.Span{``0}) +M:System.Range.#ctor(System.Index,System.Index) +M:System.Range.EndAt(System.Index) +M:System.Range.Equals(System.Object) +M:System.Range.Equals(System.Range) +M:System.Range.get_All +M:System.Range.get_End +M:System.Range.get_Start +M:System.Range.GetHashCode +M:System.Range.GetOffsetAndLength(System.Int32) +M:System.Range.StartAt(System.Index) +M:System.Range.ToString +M:System.RankException.#ctor +M:System.RankException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.RankException.#ctor(System.String) +M:System.RankException.#ctor(System.String,System.Exception) +M:System.ReadOnlyMemory`1.#ctor(`0[]) +M:System.ReadOnlyMemory`1.#ctor(`0[],System.Int32,System.Int32) +M:System.ReadOnlyMemory`1.CopyTo(System.Memory{`0}) +M:System.ReadOnlyMemory`1.Equals(System.Object) +M:System.ReadOnlyMemory`1.Equals(System.ReadOnlyMemory{`0}) +M:System.ReadOnlyMemory`1.get_Empty +M:System.ReadOnlyMemory`1.get_IsEmpty +M:System.ReadOnlyMemory`1.get_Length +M:System.ReadOnlyMemory`1.get_Span +M:System.ReadOnlyMemory`1.GetHashCode +M:System.ReadOnlyMemory`1.op_Implicit(`0[])~System.ReadOnlyMemory{`0} +M:System.ReadOnlyMemory`1.op_Implicit(System.ArraySegment{`0})~System.ReadOnlyMemory{`0} +M:System.ReadOnlyMemory`1.Pin +M:System.ReadOnlyMemory`1.Slice(System.Int32) +M:System.ReadOnlyMemory`1.Slice(System.Int32,System.Int32) +M:System.ReadOnlyMemory`1.ToArray +M:System.ReadOnlyMemory`1.ToString +M:System.ReadOnlyMemory`1.TryCopyTo(System.Memory{`0}) +M:System.ReadOnlySpan`1.#ctor(`0@) +M:System.ReadOnlySpan`1.#ctor(`0[]) +M:System.ReadOnlySpan`1.#ctor(`0[],System.Int32,System.Int32) +M:System.ReadOnlySpan`1.#ctor(System.Void*,System.Int32) +M:System.ReadOnlySpan`1.CopyTo(System.Span{`0}) +M:System.ReadOnlySpan`1.Enumerator.get_Current +M:System.ReadOnlySpan`1.Enumerator.MoveNext +M:System.ReadOnlySpan`1.Equals(System.Object) +M:System.ReadOnlySpan`1.get_Empty +M:System.ReadOnlySpan`1.get_IsEmpty +M:System.ReadOnlySpan`1.get_Item(System.Int32) +M:System.ReadOnlySpan`1.get_Length +M:System.ReadOnlySpan`1.GetEnumerator +M:System.ReadOnlySpan`1.GetHashCode +M:System.ReadOnlySpan`1.GetPinnableReference +M:System.ReadOnlySpan`1.op_Equality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0}) +M:System.ReadOnlySpan`1.op_Implicit(`0[])~System.ReadOnlySpan{`0} +M:System.ReadOnlySpan`1.op_Implicit(System.ArraySegment{`0})~System.ReadOnlySpan{`0} +M:System.ReadOnlySpan`1.op_Inequality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0}) +M:System.ReadOnlySpan`1.Slice(System.Int32) +M:System.ReadOnlySpan`1.Slice(System.Int32,System.Int32) +M:System.ReadOnlySpan`1.ToArray +M:System.ReadOnlySpan`1.ToString +M:System.ReadOnlySpan`1.TryCopyTo(System.Span{`0}) +M:System.ResolveEventArgs.#ctor(System.String) +M:System.ResolveEventArgs.#ctor(System.String,System.Reflection.Assembly) +M:System.ResolveEventArgs.get_Name +M:System.ResolveEventArgs.get_RequestingAssembly +M:System.ResolveEventHandler.#ctor(System.Object,System.IntPtr) +M:System.ResolveEventHandler.BeginInvoke(System.Object,System.ResolveEventArgs,System.AsyncCallback,System.Object) +M:System.ResolveEventHandler.EndInvoke(System.IAsyncResult) +M:System.ResolveEventHandler.Invoke(System.Object,System.ResolveEventArgs) +M:System.Runtime.CompilerServices.AccessedThroughPropertyAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.AccessedThroughPropertyAttribute.get_PropertyName +M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete +M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Create +M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.MoveNext``1(``0@) +M:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute.#ctor(System.Type) +M:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.#ctor(System.Type) +M:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.get_BuilderType +M:System.Runtime.CompilerServices.AsyncStateMachineAttribute.#ctor(System.Type) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.get_Task +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start``1(``0@) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(System.Exception) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetResult(`0) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start``1(``0@) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.Create +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.get_Task +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetException(System.Exception) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetResult +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.Start``1(``0@) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetException(System.Exception) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetResult(`0) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start``1(``0@) +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetException(System.Exception) +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetResult +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Start``1(``0@) +M:System.Runtime.CompilerServices.CallConvCdecl.#ctor +M:System.Runtime.CompilerServices.CallConvFastcall.#ctor +M:System.Runtime.CompilerServices.CallConvMemberFunction.#ctor +M:System.Runtime.CompilerServices.CallConvStdcall.#ctor +M:System.Runtime.CompilerServices.CallConvSuppressGCTransition.#ctor +M:System.Runtime.CompilerServices.CallConvThiscall.#ctor +M:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.get_ParameterName +M:System.Runtime.CompilerServices.CallerFilePathAttribute.#ctor +M:System.Runtime.CompilerServices.CallerLineNumberAttribute.#ctor +M:System.Runtime.CompilerServices.CallerMemberNameAttribute.#ctor +M:System.Runtime.CompilerServices.CollectionBuilderAttribute.#ctor(System.Type,System.String) +M:System.Runtime.CompilerServices.CollectionBuilderAttribute.get_BuilderType +M:System.Runtime.CompilerServices.CollectionBuilderAttribute.get_MethodName +M:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.#ctor(System.Int32) +M:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.#ctor(System.Runtime.CompilerServices.CompilationRelaxations) +M:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.get_CompilationRelaxations +M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.get_FeatureName +M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.get_IsOptional +M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.set_IsOptional(System.Boolean) +M:System.Runtime.CompilerServices.CompilerGeneratedAttribute.#ctor +M:System.Runtime.CompilerServices.CompilerGlobalScopeAttribute.#ctor +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.#ctor +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.Add(`0,`1) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.AddOrUpdate(`0,`1) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.Clear +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.#ctor(System.Object,System.IntPtr) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.BeginInvoke(`0,System.AsyncCallback,System.Object) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.EndInvoke(System.IAsyncResult) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.Invoke(`0) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.GetOrCreateValue(`0) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.GetValue(`0,System.Runtime.CompilerServices.ConditionalWeakTable{`0,`1}.CreateValueCallback) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.Remove(`0) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.TryAdd(`0,`1) +M:System.Runtime.CompilerServices.ConditionalWeakTable`2.TryGetValue(`0,`1@) +M:System.Runtime.CompilerServices.ConfiguredAsyncDisposable.DisposeAsync +M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.ConfigureAwait(System.Boolean) +M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.DisposeAsync +M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.get_Current +M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.MoveNextAsync +M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.GetAsyncEnumerator +M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.WithCancellation(System.Threading.CancellationToken) +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.GetResult +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.GetAwaiter +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.GetResult +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.GetAwaiter +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.GetResult +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.GetAwaiter +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.GetResult +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.GetAwaiter +M:System.Runtime.CompilerServices.CustomConstantAttribute.#ctor +M:System.Runtime.CompilerServices.CustomConstantAttribute.get_Value +M:System.Runtime.CompilerServices.DateTimeConstantAttribute.#ctor(System.Int64) +M:System.Runtime.CompilerServices.DateTimeConstantAttribute.get_Value +M:System.Runtime.CompilerServices.DecimalConstantAttribute.#ctor(System.Byte,System.Byte,System.Int32,System.Int32,System.Int32) +M:System.Runtime.CompilerServices.DecimalConstantAttribute.#ctor(System.Byte,System.Byte,System.UInt32,System.UInt32,System.UInt32) +M:System.Runtime.CompilerServices.DecimalConstantAttribute.get_Value +M:System.Runtime.CompilerServices.DefaultDependencyAttribute.#ctor(System.Runtime.CompilerServices.LoadHint) +M:System.Runtime.CompilerServices.DefaultDependencyAttribute.get_LoadHint +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.IFormatProvider) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.IFormatProvider,System.Span{System.Char}) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(System.String) +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToString +M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear +M:System.Runtime.CompilerServices.DependencyAttribute.#ctor(System.String,System.Runtime.CompilerServices.LoadHint) +M:System.Runtime.CompilerServices.DependencyAttribute.get_DependentAssembly +M:System.Runtime.CompilerServices.DependencyAttribute.get_LoadHint +M:System.Runtime.CompilerServices.DisablePrivateReflectionAttribute.#ctor +M:System.Runtime.CompilerServices.DisableRuntimeMarshallingAttribute.#ctor +M:System.Runtime.CompilerServices.DiscardableAttribute.#ctor +M:System.Runtime.CompilerServices.EnumeratorCancellationAttribute.#ctor +M:System.Runtime.CompilerServices.ExtensionAttribute.#ctor +M:System.Runtime.CompilerServices.FixedAddressValueTypeAttribute.#ctor +M:System.Runtime.CompilerServices.FixedBufferAttribute.#ctor(System.Type,System.Int32) +M:System.Runtime.CompilerServices.FixedBufferAttribute.get_ElementType +M:System.Runtime.CompilerServices.FixedBufferAttribute.get_Length +M:System.Runtime.CompilerServices.FormattableStringFactory.Create(System.String,System.Object[]) +M:System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext +M:System.Runtime.CompilerServices.IAsyncStateMachine.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.ICriticalNotifyCompletion.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.IndexerNameAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.InlineArrayAttribute.#ctor(System.Int32) +M:System.Runtime.CompilerServices.InlineArrayAttribute.get_Length +M:System.Runtime.CompilerServices.INotifyCompletion.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.get_AllInternalsVisible +M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.get_AssemblyName +M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.set_AllInternalsVisible(System.Boolean) +M:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.#ctor(System.String[]) +M:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.get_Arguments +M:System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute.#ctor +M:System.Runtime.CompilerServices.IsByRefLikeAttribute.#ctor +M:System.Runtime.CompilerServices.IsReadOnlyAttribute.#ctor +M:System.Runtime.CompilerServices.IStrongBox.get_Value +M:System.Runtime.CompilerServices.IStrongBox.set_Value(System.Object) +M:System.Runtime.CompilerServices.IsUnmanagedAttribute.#ctor +M:System.Runtime.CompilerServices.IteratorStateMachineAttribute.#ctor(System.Type) +M:System.Runtime.CompilerServices.ITuple.get_Item(System.Int32) +M:System.Runtime.CompilerServices.ITuple.get_Length +M:System.Runtime.CompilerServices.MethodImplAttribute.#ctor +M:System.Runtime.CompilerServices.MethodImplAttribute.#ctor(System.Int16) +M:System.Runtime.CompilerServices.MethodImplAttribute.#ctor(System.Runtime.CompilerServices.MethodImplOptions) +M:System.Runtime.CompilerServices.MethodImplAttribute.get_Value +M:System.Runtime.CompilerServices.ModuleInitializerAttribute.#ctor +M:System.Runtime.CompilerServices.NullableAttribute.#ctor(System.Byte) +M:System.Runtime.CompilerServices.NullableAttribute.#ctor(System.Byte[]) +M:System.Runtime.CompilerServices.NullableContextAttribute.#ctor(System.Byte) +M:System.Runtime.CompilerServices.NullablePublicOnlyAttribute.#ctor(System.Boolean) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.Create +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.get_Task +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetException(System.Exception) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetResult +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.Start``1(``0@) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.Create +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.get_Task +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetException(System.Exception) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetResult(`0) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) +M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.Start``1(``0@) +M:System.Runtime.CompilerServices.PreserveBaseOverridesAttribute.#ctor +M:System.Runtime.CompilerServices.ReferenceAssemblyAttribute.#ctor +M:System.Runtime.CompilerServices.ReferenceAssemblyAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.ReferenceAssemblyAttribute.get_Description +M:System.Runtime.CompilerServices.RefSafetyRulesAttribute.#ctor(System.Int32) +M:System.Runtime.CompilerServices.RefSafetyRulesAttribute.get_Version +M:System.Runtime.CompilerServices.RequiredMemberAttribute.#ctor +M:System.Runtime.CompilerServices.RequiresLocationAttribute.#ctor +M:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.#ctor +M:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.get_WrapNonExceptionThrows +M:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.set_WrapNonExceptionThrows(System.Boolean) +M:System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeCompiled +M:System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeSupported +M:System.Runtime.CompilerServices.RuntimeFeature.IsSupported(System.String) +M:System.Runtime.CompilerServices.RuntimeHelpers.AllocateTypeAssociatedMemory(System.Type,System.Int32) +M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.#ctor(System.Object,System.IntPtr) +M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.BeginInvoke(System.Object,System.Boolean,System.AsyncCallback,System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.EndInvoke(System.IAsyncResult) +M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.Invoke(System.Object,System.Boolean) +M:System.Runtime.CompilerServices.RuntimeHelpers.CreateSpan``1(System.RuntimeFieldHandle) +M:System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack +M:System.Runtime.CompilerServices.RuntimeHelpers.Equals(System.Object,System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(System.Runtime.CompilerServices.RuntimeHelpers.TryCode,System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode,System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.get_OffsetToStringData +M:System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.GetSubArray``1(``0[],System.Range) +M:System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(System.Type) +M:System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray(System.Array,System.RuntimeFieldHandle) +M:System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences``1 +M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions +M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegionsNoOP +M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareContractedDelegate(System.Delegate) +M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareDelegate(System.Delegate) +M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMethodHandle) +M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMethodHandle,System.RuntimeTypeHandle[]) +M:System.Runtime.CompilerServices.RuntimeHelpers.ProbeForSufficientStack +M:System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(System.RuntimeTypeHandle) +M:System.Runtime.CompilerServices.RuntimeHelpers.RunModuleConstructor(System.ModuleHandle) +M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.#ctor(System.Object,System.IntPtr) +M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.BeginInvoke(System.Object,System.AsyncCallback,System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.EndInvoke(System.IAsyncResult) +M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.Invoke(System.Object) +M:System.Runtime.CompilerServices.RuntimeHelpers.TryEnsureSufficientExecutionStack +M:System.Runtime.CompilerServices.RuntimeWrappedException.#ctor(System.Object) +M:System.Runtime.CompilerServices.RuntimeWrappedException.get_WrappedException +M:System.Runtime.CompilerServices.RuntimeWrappedException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Runtime.CompilerServices.ScopedRefAttribute.#ctor +M:System.Runtime.CompilerServices.SkipLocalsInitAttribute.#ctor +M:System.Runtime.CompilerServices.SpecialNameAttribute.#ctor +M:System.Runtime.CompilerServices.StateMachineAttribute.#ctor(System.Type) +M:System.Runtime.CompilerServices.StateMachineAttribute.get_StateMachineType +M:System.Runtime.CompilerServices.StringFreezingAttribute.#ctor +M:System.Runtime.CompilerServices.StrongBox`1.#ctor +M:System.Runtime.CompilerServices.StrongBox`1.#ctor(`0) +M:System.Runtime.CompilerServices.SuppressIldasmAttribute.#ctor +M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor +M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.Exception) +M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.Object) +M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.String) +M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.String,System.Exception) +M:System.Runtime.CompilerServices.SwitchExpressionException.get_Message +M:System.Runtime.CompilerServices.SwitchExpressionException.get_UnmatchedValue +M:System.Runtime.CompilerServices.SwitchExpressionException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Runtime.CompilerServices.TaskAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.TaskAwaiter.GetResult +M:System.Runtime.CompilerServices.TaskAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.TaskAwaiter.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.TaskAwaiter`1.get_IsCompleted +M:System.Runtime.CompilerServices.TaskAwaiter`1.GetResult +M:System.Runtime.CompilerServices.TaskAwaiter`1.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.TaskAwaiter`1.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.TupleElementNamesAttribute.#ctor(System.String[]) +M:System.Runtime.CompilerServices.TupleElementNamesAttribute.get_TransformNames +M:System.Runtime.CompilerServices.TypeForwardedFromAttribute.#ctor(System.String) +M:System.Runtime.CompilerServices.TypeForwardedFromAttribute.get_AssemblyFullName +M:System.Runtime.CompilerServices.TypeForwardedToAttribute.#ctor(System.Type) +M:System.Runtime.CompilerServices.TypeForwardedToAttribute.get_Destination +M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.Int32) +M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.IntPtr) +M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.UIntPtr) +M:System.Runtime.CompilerServices.Unsafe.Add``1(System.Void*,System.Int32) +M:System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.IntPtr) +M:System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.UIntPtr) +M:System.Runtime.CompilerServices.Unsafe.AreSame``1(``0@,``0@) +M:System.Runtime.CompilerServices.Unsafe.As``1(System.Object) +M:System.Runtime.CompilerServices.Unsafe.As``2(``0@) +M:System.Runtime.CompilerServices.Unsafe.AsPointer``1(``0@) +M:System.Runtime.CompilerServices.Unsafe.AsRef``1(``0@) +M:System.Runtime.CompilerServices.Unsafe.AsRef``1(System.Void*) +M:System.Runtime.CompilerServices.Unsafe.BitCast``2(``0) +M:System.Runtime.CompilerServices.Unsafe.ByteOffset``1(``0@,``0@) +M:System.Runtime.CompilerServices.Unsafe.Copy``1(``0@,System.Void*) +M:System.Runtime.CompilerServices.Unsafe.Copy``1(System.Void*,``0@) +M:System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Byte@,System.Byte@,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Void*,System.Void*,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Byte@,System.Byte@,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Void*,System.Void*,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.InitBlock(System.Byte@,System.Byte,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.InitBlock(System.Void*,System.Byte,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Byte@,System.Byte,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Void*,System.Byte,System.UInt32) +M:System.Runtime.CompilerServices.Unsafe.IsAddressGreaterThan``1(``0@,``0@) +M:System.Runtime.CompilerServices.Unsafe.IsAddressLessThan``1(``0@,``0@) +M:System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@) +M:System.Runtime.CompilerServices.Unsafe.NullRef``1 +M:System.Runtime.CompilerServices.Unsafe.Read``1(System.Void*) +M:System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Byte@) +M:System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Void*) +M:System.Runtime.CompilerServices.Unsafe.SizeOf``1 +M:System.Runtime.CompilerServices.Unsafe.SkipInit``1(``0@) +M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.Int32) +M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.IntPtr) +M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.UIntPtr) +M:System.Runtime.CompilerServices.Unsafe.Subtract``1(System.Void*,System.Int32) +M:System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.IntPtr) +M:System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.UIntPtr) +M:System.Runtime.CompilerServices.Unsafe.Unbox``1(System.Object) +M:System.Runtime.CompilerServices.Unsafe.Write``1(System.Void*,``0) +M:System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Byte@,``0) +M:System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Void*,``0) +M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.#ctor(System.Runtime.CompilerServices.UnsafeAccessorKind) +M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.get_Kind +M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.get_Name +M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.set_Name(System.String) +M:System.Runtime.CompilerServices.UnsafeValueTypeAttribute.#ctor +M:System.Runtime.CompilerServices.ValueTaskAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult +M:System.Runtime.CompilerServices.ValueTaskAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.ValueTaskAwaiter.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.get_IsCompleted +M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult +M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.UnsafeOnCompleted(System.Action) +M:System.Runtime.CompilerServices.YieldAwaitable.GetAwaiter +M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.get_IsCompleted +M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.GetResult +M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.OnCompleted(System.Action) +M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.UnsafeOnCompleted(System.Action) +M:System.RuntimeFieldHandle.Equals(System.Object) +M:System.RuntimeFieldHandle.Equals(System.RuntimeFieldHandle) +M:System.RuntimeFieldHandle.FromIntPtr(System.IntPtr) +M:System.RuntimeFieldHandle.get_Value +M:System.RuntimeFieldHandle.GetHashCode +M:System.RuntimeFieldHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.RuntimeFieldHandle.op_Equality(System.RuntimeFieldHandle,System.RuntimeFieldHandle) +M:System.RuntimeFieldHandle.op_Inequality(System.RuntimeFieldHandle,System.RuntimeFieldHandle) +M:System.RuntimeFieldHandle.ToIntPtr(System.RuntimeFieldHandle) +M:System.RuntimeMethodHandle.Equals(System.Object) +M:System.RuntimeMethodHandle.Equals(System.RuntimeMethodHandle) +M:System.RuntimeMethodHandle.FromIntPtr(System.IntPtr) +M:System.RuntimeMethodHandle.get_Value +M:System.RuntimeMethodHandle.GetFunctionPointer +M:System.RuntimeMethodHandle.GetHashCode +M:System.RuntimeMethodHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.RuntimeMethodHandle.op_Equality(System.RuntimeMethodHandle,System.RuntimeMethodHandle) +M:System.RuntimeMethodHandle.op_Inequality(System.RuntimeMethodHandle,System.RuntimeMethodHandle) +M:System.RuntimeMethodHandle.ToIntPtr(System.RuntimeMethodHandle) +M:System.RuntimeTypeHandle.Equals(System.Object) +M:System.RuntimeTypeHandle.Equals(System.RuntimeTypeHandle) +M:System.RuntimeTypeHandle.FromIntPtr(System.IntPtr) +M:System.RuntimeTypeHandle.get_Value +M:System.RuntimeTypeHandle.GetHashCode +M:System.RuntimeTypeHandle.GetModuleHandle +M:System.RuntimeTypeHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.RuntimeTypeHandle.op_Equality(System.Object,System.RuntimeTypeHandle) +M:System.RuntimeTypeHandle.op_Equality(System.RuntimeTypeHandle,System.Object) +M:System.RuntimeTypeHandle.op_Inequality(System.Object,System.RuntimeTypeHandle) +M:System.RuntimeTypeHandle.op_Inequality(System.RuntimeTypeHandle,System.Object) +M:System.RuntimeTypeHandle.ToIntPtr(System.RuntimeTypeHandle) +M:System.SByte.Abs(System.SByte) +M:System.SByte.Clamp(System.SByte,System.SByte,System.SByte) +M:System.SByte.CompareTo(System.Object) +M:System.SByte.CompareTo(System.SByte) +M:System.SByte.CopySign(System.SByte,System.SByte) +M:System.SByte.CreateChecked``1(``0) +M:System.SByte.CreateSaturating``1(``0) +M:System.SByte.CreateTruncating``1(``0) +M:System.SByte.DivRem(System.SByte,System.SByte) +M:System.SByte.Equals(System.Object) +M:System.SByte.Equals(System.SByte) +M:System.SByte.GetHashCode +M:System.SByte.GetTypeCode +M:System.SByte.IsEvenInteger(System.SByte) +M:System.SByte.IsNegative(System.SByte) +M:System.SByte.IsOddInteger(System.SByte) +M:System.SByte.IsPositive(System.SByte) +M:System.SByte.IsPow2(System.SByte) +M:System.SByte.LeadingZeroCount(System.SByte) +M:System.SByte.Log2(System.SByte) +M:System.SByte.Max(System.SByte,System.SByte) +M:System.SByte.MaxMagnitude(System.SByte,System.SByte) +M:System.SByte.Min(System.SByte,System.SByte) +M:System.SByte.MinMagnitude(System.SByte,System.SByte) +M:System.SByte.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.SByte.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.SByte.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.SByte.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.SByte.Parse(System.String) +M:System.SByte.Parse(System.String,System.Globalization.NumberStyles) +M:System.SByte.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.SByte.Parse(System.String,System.IFormatProvider) +M:System.SByte.PopCount(System.SByte) +M:System.SByte.RotateLeft(System.SByte,System.Int32) +M:System.SByte.RotateRight(System.SByte,System.Int32) +M:System.SByte.Sign(System.SByte) +M:System.SByte.ToString +M:System.SByte.ToString(System.IFormatProvider) +M:System.SByte.ToString(System.String) +M:System.SByte.ToString(System.String,System.IFormatProvider) +M:System.SByte.TrailingZeroCount(System.SByte) +M:System.SByte.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.SByte.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) +M:System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.SByte@) +M:System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.SByte@) +M:System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) +M:System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.SByte@) +M:System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.SByte@) +M:System.SByte.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) +M:System.SByte.TryParse(System.String,System.IFormatProvider,System.SByte@) +M:System.SByte.TryParse(System.String,System.SByte@) +M:System.SerializableAttribute.#ctor +M:System.Single.Abs(System.Single) +M:System.Single.Acos(System.Single) +M:System.Single.Acosh(System.Single) +M:System.Single.AcosPi(System.Single) +M:System.Single.Asin(System.Single) +M:System.Single.Asinh(System.Single) +M:System.Single.AsinPi(System.Single) +M:System.Single.Atan(System.Single) +M:System.Single.Atan2(System.Single,System.Single) +M:System.Single.Atan2Pi(System.Single,System.Single) +M:System.Single.Atanh(System.Single) +M:System.Single.AtanPi(System.Single) +M:System.Single.BitDecrement(System.Single) +M:System.Single.BitIncrement(System.Single) +M:System.Single.Cbrt(System.Single) +M:System.Single.Ceiling(System.Single) +M:System.Single.Clamp(System.Single,System.Single,System.Single) +M:System.Single.CompareTo(System.Object) +M:System.Single.CompareTo(System.Single) +M:System.Single.CopySign(System.Single,System.Single) +M:System.Single.Cos(System.Single) +M:System.Single.Cosh(System.Single) +M:System.Single.CosPi(System.Single) +M:System.Single.CreateChecked``1(``0) +M:System.Single.CreateSaturating``1(``0) +M:System.Single.CreateTruncating``1(``0) +M:System.Single.DegreesToRadians(System.Single) +M:System.Single.Equals(System.Object) +M:System.Single.Equals(System.Single) +M:System.Single.Exp(System.Single) +M:System.Single.Exp10(System.Single) +M:System.Single.Exp10M1(System.Single) +M:System.Single.Exp2(System.Single) +M:System.Single.Exp2M1(System.Single) +M:System.Single.ExpM1(System.Single) +M:System.Single.Floor(System.Single) +M:System.Single.FusedMultiplyAdd(System.Single,System.Single,System.Single) +M:System.Single.GetHashCode +M:System.Single.GetTypeCode +M:System.Single.Hypot(System.Single,System.Single) +M:System.Single.Ieee754Remainder(System.Single,System.Single) +M:System.Single.ILogB(System.Single) +M:System.Single.IsEvenInteger(System.Single) +M:System.Single.IsFinite(System.Single) +M:System.Single.IsInfinity(System.Single) +M:System.Single.IsInteger(System.Single) +M:System.Single.IsNaN(System.Single) +M:System.Single.IsNegative(System.Single) +M:System.Single.IsNegativeInfinity(System.Single) +M:System.Single.IsNormal(System.Single) +M:System.Single.IsOddInteger(System.Single) +M:System.Single.IsPositive(System.Single) +M:System.Single.IsPositiveInfinity(System.Single) +M:System.Single.IsPow2(System.Single) +M:System.Single.IsRealNumber(System.Single) +M:System.Single.IsSubnormal(System.Single) +M:System.Single.Lerp(System.Single,System.Single,System.Single) +M:System.Single.Log(System.Single) +M:System.Single.Log(System.Single,System.Single) +M:System.Single.Log10(System.Single) +M:System.Single.Log10P1(System.Single) +M:System.Single.Log2(System.Single) +M:System.Single.Log2P1(System.Single) +M:System.Single.LogP1(System.Single) +M:System.Single.Max(System.Single,System.Single) +M:System.Single.MaxMagnitude(System.Single,System.Single) +M:System.Single.MaxMagnitudeNumber(System.Single,System.Single) +M:System.Single.MaxNumber(System.Single,System.Single) +M:System.Single.Min(System.Single,System.Single) +M:System.Single.MinMagnitude(System.Single,System.Single) +M:System.Single.MinMagnitudeNumber(System.Single,System.Single) +M:System.Single.MinNumber(System.Single,System.Single) +M:System.Single.op_Equality(System.Single,System.Single) +M:System.Single.op_GreaterThan(System.Single,System.Single) +M:System.Single.op_GreaterThanOrEqual(System.Single,System.Single) +M:System.Single.op_Inequality(System.Single,System.Single) +M:System.Single.op_LessThan(System.Single,System.Single) +M:System.Single.op_LessThanOrEqual(System.Single,System.Single) +M:System.Single.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Single.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.Single.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Single.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Single.Parse(System.String) +M:System.Single.Parse(System.String,System.Globalization.NumberStyles) +M:System.Single.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.Single.Parse(System.String,System.IFormatProvider) +M:System.Single.Pow(System.Single,System.Single) +M:System.Single.RadiansToDegrees(System.Single) +M:System.Single.ReciprocalEstimate(System.Single) +M:System.Single.ReciprocalSqrtEstimate(System.Single) +M:System.Single.RootN(System.Single,System.Int32) +M:System.Single.Round(System.Single) +M:System.Single.Round(System.Single,System.Int32) +M:System.Single.Round(System.Single,System.Int32,System.MidpointRounding) +M:System.Single.Round(System.Single,System.MidpointRounding) +M:System.Single.ScaleB(System.Single,System.Int32) +M:System.Single.Sign(System.Single) +M:System.Single.Sin(System.Single) +M:System.Single.SinCos(System.Single) +M:System.Single.SinCosPi(System.Single) +M:System.Single.Sinh(System.Single) +M:System.Single.SinPi(System.Single) +M:System.Single.Sqrt(System.Single) +M:System.Single.Tan(System.Single) +M:System.Single.Tanh(System.Single) +M:System.Single.TanPi(System.Single) +M:System.Single.ToString +M:System.Single.ToString(System.IFormatProvider) +M:System.Single.ToString(System.String) +M:System.Single.ToString(System.String,System.IFormatProvider) +M:System.Single.Truncate(System.Single) +M:System.Single.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Single.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) +M:System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Single@) +M:System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.Single@) +M:System.Single.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) +M:System.Single.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Single@) +M:System.Single.TryParse(System.ReadOnlySpan{System.Char},System.Single@) +M:System.Single.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) +M:System.Single.TryParse(System.String,System.IFormatProvider,System.Single@) +M:System.Single.TryParse(System.String,System.Single@) +M:System.Span`1.#ctor(`0@) +M:System.Span`1.#ctor(`0[]) +M:System.Span`1.#ctor(`0[],System.Int32,System.Int32) +M:System.Span`1.#ctor(System.Void*,System.Int32) +M:System.Span`1.Clear +M:System.Span`1.CopyTo(System.Span{`0}) +M:System.Span`1.Enumerator.get_Current +M:System.Span`1.Enumerator.MoveNext +M:System.Span`1.Equals(System.Object) +M:System.Span`1.Fill(`0) +M:System.Span`1.get_Empty +M:System.Span`1.get_IsEmpty +M:System.Span`1.get_Item(System.Int32) +M:System.Span`1.get_Length +M:System.Span`1.GetEnumerator +M:System.Span`1.GetHashCode +M:System.Span`1.GetPinnableReference +M:System.Span`1.op_Equality(System.Span{`0},System.Span{`0}) +M:System.Span`1.op_Implicit(`0[])~System.Span{`0} +M:System.Span`1.op_Implicit(System.ArraySegment{`0})~System.Span{`0} +M:System.Span`1.op_Implicit(System.Span{`0})~System.ReadOnlySpan{`0} +M:System.Span`1.op_Inequality(System.Span{`0},System.Span{`0}) +M:System.Span`1.Slice(System.Int32) +M:System.Span`1.Slice(System.Int32,System.Int32) +M:System.Span`1.ToArray +M:System.Span`1.ToString +M:System.Span`1.TryCopyTo(System.Span{`0}) +M:System.StackOverflowException.#ctor +M:System.StackOverflowException.#ctor(System.String) +M:System.StackOverflowException.#ctor(System.String,System.Exception) +M:System.String.#ctor(System.Char*) +M:System.String.#ctor(System.Char*,System.Int32,System.Int32) +M:System.String.#ctor(System.Char,System.Int32) +M:System.String.#ctor(System.Char[]) +M:System.String.#ctor(System.Char[],System.Int32,System.Int32) +M:System.String.#ctor(System.ReadOnlySpan{System.Char}) +M:System.String.#ctor(System.SByte*) +M:System.String.#ctor(System.SByte*,System.Int32,System.Int32) +M:System.String.#ctor(System.SByte*,System.Int32,System.Int32,System.Text.Encoding) +M:System.String.Clone +M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32) +M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean) +M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean,System.Globalization.CultureInfo) +M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CultureInfo,System.Globalization.CompareOptions) +M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.StringComparison) +M:System.String.Compare(System.String,System.String) +M:System.String.Compare(System.String,System.String,System.Boolean) +M:System.String.Compare(System.String,System.String,System.Boolean,System.Globalization.CultureInfo) +M:System.String.Compare(System.String,System.String,System.Globalization.CultureInfo,System.Globalization.CompareOptions) +M:System.String.Compare(System.String,System.String,System.StringComparison) +M:System.String.CompareOrdinal(System.String,System.Int32,System.String,System.Int32,System.Int32) +M:System.String.CompareOrdinal(System.String,System.String) +M:System.String.CompareTo(System.Object) +M:System.String.CompareTo(System.String) +M:System.String.Concat(System.Collections.Generic.IEnumerable{System.String}) +M:System.String.Concat(System.Object) +M:System.String.Concat(System.Object,System.Object) +M:System.String.Concat(System.Object,System.Object,System.Object) +M:System.String.Concat(System.Object[]) +M:System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:System.String.Concat(System.String,System.String) +M:System.String.Concat(System.String,System.String,System.String) +M:System.String.Concat(System.String,System.String,System.String,System.String) +M:System.String.Concat(System.String[]) +M:System.String.Concat``1(System.Collections.Generic.IEnumerable{``0}) +M:System.String.Contains(System.Char) +M:System.String.Contains(System.Char,System.StringComparison) +M:System.String.Contains(System.String) +M:System.String.Contains(System.String,System.StringComparison) +M:System.String.Copy(System.String) +M:System.String.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) +M:System.String.CopyTo(System.Span{System.Char}) +M:System.String.Create(System.IFormatProvider,System.Runtime.CompilerServices.DefaultInterpolatedStringHandler@) +M:System.String.Create(System.IFormatProvider,System.Span{System.Char},System.Runtime.CompilerServices.DefaultInterpolatedStringHandler@) +M:System.String.Create``1(System.Int32,``0,System.Buffers.SpanAction{System.Char,``0}) +M:System.String.EndsWith(System.Char) +M:System.String.EndsWith(System.String) +M:System.String.EndsWith(System.String,System.Boolean,System.Globalization.CultureInfo) +M:System.String.EndsWith(System.String,System.StringComparison) +M:System.String.EnumerateRunes +M:System.String.Equals(System.Object) +M:System.String.Equals(System.String) +M:System.String.Equals(System.String,System.String) +M:System.String.Equals(System.String,System.String,System.StringComparison) +M:System.String.Equals(System.String,System.StringComparison) +M:System.String.Format(System.IFormatProvider,System.String,System.Object) +M:System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object) +M:System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) +M:System.String.Format(System.IFormatProvider,System.String,System.Object[]) +M:System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) +M:System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) +M:System.String.Format(System.String,System.Object) +M:System.String.Format(System.String,System.Object,System.Object) +M:System.String.Format(System.String,System.Object,System.Object,System.Object) +M:System.String.Format(System.String,System.Object[]) +M:System.String.Format``1(System.IFormatProvider,System.Text.CompositeFormat,``0) +M:System.String.Format``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) +M:System.String.Format``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) +M:System.String.get_Chars(System.Int32) +M:System.String.get_Length +M:System.String.GetEnumerator +M:System.String.GetHashCode +M:System.String.GetHashCode(System.ReadOnlySpan{System.Char}) +M:System.String.GetHashCode(System.ReadOnlySpan{System.Char},System.StringComparison) +M:System.String.GetHashCode(System.StringComparison) +M:System.String.GetPinnableReference +M:System.String.GetTypeCode +M:System.String.IndexOf(System.Char) +M:System.String.IndexOf(System.Char,System.Int32) +M:System.String.IndexOf(System.Char,System.Int32,System.Int32) +M:System.String.IndexOf(System.Char,System.StringComparison) +M:System.String.IndexOf(System.String) +M:System.String.IndexOf(System.String,System.Int32) +M:System.String.IndexOf(System.String,System.Int32,System.Int32) +M:System.String.IndexOf(System.String,System.Int32,System.Int32,System.StringComparison) +M:System.String.IndexOf(System.String,System.Int32,System.StringComparison) +M:System.String.IndexOf(System.String,System.StringComparison) +M:System.String.IndexOfAny(System.Char[]) +M:System.String.IndexOfAny(System.Char[],System.Int32) +M:System.String.IndexOfAny(System.Char[],System.Int32,System.Int32) +M:System.String.Insert(System.Int32,System.String) +M:System.String.Intern(System.String) +M:System.String.IsInterned(System.String) +M:System.String.IsNormalized +M:System.String.IsNormalized(System.Text.NormalizationForm) +M:System.String.IsNullOrEmpty(System.String) +M:System.String.IsNullOrWhiteSpace(System.String) +M:System.String.Join(System.Char,System.Object[]) +M:System.String.Join(System.Char,System.String[]) +M:System.String.Join(System.Char,System.String[],System.Int32,System.Int32) +M:System.String.Join(System.String,System.Collections.Generic.IEnumerable{System.String}) +M:System.String.Join(System.String,System.Object[]) +M:System.String.Join(System.String,System.String[]) +M:System.String.Join(System.String,System.String[],System.Int32,System.Int32) +M:System.String.Join``1(System.Char,System.Collections.Generic.IEnumerable{``0}) +M:System.String.Join``1(System.String,System.Collections.Generic.IEnumerable{``0}) +M:System.String.LastIndexOf(System.Char) +M:System.String.LastIndexOf(System.Char,System.Int32) +M:System.String.LastIndexOf(System.Char,System.Int32,System.Int32) +M:System.String.LastIndexOf(System.String) +M:System.String.LastIndexOf(System.String,System.Int32) +M:System.String.LastIndexOf(System.String,System.Int32,System.Int32) +M:System.String.LastIndexOf(System.String,System.Int32,System.Int32,System.StringComparison) +M:System.String.LastIndexOf(System.String,System.Int32,System.StringComparison) +M:System.String.LastIndexOf(System.String,System.StringComparison) +M:System.String.LastIndexOfAny(System.Char[]) +M:System.String.LastIndexOfAny(System.Char[],System.Int32) +M:System.String.LastIndexOfAny(System.Char[],System.Int32,System.Int32) +M:System.String.Normalize +M:System.String.Normalize(System.Text.NormalizationForm) +M:System.String.op_Equality(System.String,System.String) +M:System.String.op_Implicit(System.String)~System.ReadOnlySpan{System.Char} +M:System.String.op_Inequality(System.String,System.String) +M:System.String.PadLeft(System.Int32) +M:System.String.PadLeft(System.Int32,System.Char) +M:System.String.PadRight(System.Int32) +M:System.String.PadRight(System.Int32,System.Char) +M:System.String.Remove(System.Int32) +M:System.String.Remove(System.Int32,System.Int32) +M:System.String.Replace(System.Char,System.Char) +M:System.String.Replace(System.String,System.String) +M:System.String.Replace(System.String,System.String,System.Boolean,System.Globalization.CultureInfo) +M:System.String.Replace(System.String,System.String,System.StringComparison) +M:System.String.ReplaceLineEndings +M:System.String.ReplaceLineEndings(System.String) +M:System.String.Split(System.Char,System.Int32,System.StringSplitOptions) +M:System.String.Split(System.Char,System.StringSplitOptions) +M:System.String.Split(System.Char[]) +M:System.String.Split(System.Char[],System.Int32) +M:System.String.Split(System.Char[],System.Int32,System.StringSplitOptions) +M:System.String.Split(System.Char[],System.StringSplitOptions) +M:System.String.Split(System.String,System.Int32,System.StringSplitOptions) +M:System.String.Split(System.String,System.StringSplitOptions) +M:System.String.Split(System.String[],System.Int32,System.StringSplitOptions) +M:System.String.Split(System.String[],System.StringSplitOptions) +M:System.String.StartsWith(System.Char) +M:System.String.StartsWith(System.String) +M:System.String.StartsWith(System.String,System.Boolean,System.Globalization.CultureInfo) +M:System.String.StartsWith(System.String,System.StringComparison) +M:System.String.Substring(System.Int32) +M:System.String.Substring(System.Int32,System.Int32) +M:System.String.ToCharArray +M:System.String.ToCharArray(System.Int32,System.Int32) +M:System.String.ToLower +M:System.String.ToLower(System.Globalization.CultureInfo) +M:System.String.ToLowerInvariant +M:System.String.ToString +M:System.String.ToString(System.IFormatProvider) +M:System.String.ToUpper +M:System.String.ToUpper(System.Globalization.CultureInfo) +M:System.String.ToUpperInvariant +M:System.String.Trim +M:System.String.Trim(System.Char) +M:System.String.Trim(System.Char[]) +M:System.String.TrimEnd +M:System.String.TrimEnd(System.Char) +M:System.String.TrimEnd(System.Char[]) +M:System.String.TrimStart +M:System.String.TrimStart(System.Char) +M:System.String.TrimStart(System.Char[]) +M:System.String.TryCopyTo(System.Span{System.Char}) +M:System.StringComparer.#ctor +M:System.StringComparer.Compare(System.Object,System.Object) +M:System.StringComparer.Compare(System.String,System.String) +M:System.StringComparer.Create(System.Globalization.CultureInfo,System.Boolean) +M:System.StringComparer.Create(System.Globalization.CultureInfo,System.Globalization.CompareOptions) +M:System.StringComparer.Equals(System.Object,System.Object) +M:System.StringComparer.Equals(System.String,System.String) +M:System.StringComparer.FromComparison(System.StringComparison) +M:System.StringComparer.get_CurrentCulture +M:System.StringComparer.get_CurrentCultureIgnoreCase +M:System.StringComparer.get_InvariantCulture +M:System.StringComparer.get_InvariantCultureIgnoreCase +M:System.StringComparer.get_Ordinal +M:System.StringComparer.get_OrdinalIgnoreCase +M:System.StringComparer.GetHashCode(System.Object) +M:System.StringComparer.GetHashCode(System.String) +M:System.StringComparer.IsWellKnownCultureAwareComparer(System.Collections.Generic.IEqualityComparer{System.String},System.Globalization.CompareInfo@,System.Globalization.CompareOptions@) +M:System.StringComparer.IsWellKnownOrdinalComparer(System.Collections.Generic.IEqualityComparer{System.String},System.Boolean@) +M:System.StringNormalizationExtensions.IsNormalized(System.String) +M:System.StringNormalizationExtensions.IsNormalized(System.String,System.Text.NormalizationForm) +M:System.StringNormalizationExtensions.Normalize(System.String) +M:System.StringNormalizationExtensions.Normalize(System.String,System.Text.NormalizationForm) +M:System.SystemException.#ctor +M:System.SystemException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.SystemException.#ctor(System.String) +M:System.SystemException.#ctor(System.String,System.Exception) +M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.FromUtf16(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.IsValid(System.Byte) +M:System.Text.Ascii.IsValid(System.Char) +M:System.Text.Ascii.IsValid(System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.IsValid(System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.ToLowerInPlace(System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.ToLowerInPlace(System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.ToUpperInPlace(System.Span{System.Byte},System.Int32@) +M:System.Text.Ascii.ToUpperInPlace(System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.ToUtf16(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +M:System.Text.Ascii.Trim(System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.Trim(System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.TrimEnd(System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.TrimEnd(System.ReadOnlySpan{System.Char}) +M:System.Text.Ascii.TrimStart(System.ReadOnlySpan{System.Byte}) +M:System.Text.Ascii.TrimStart(System.ReadOnlySpan{System.Char}) +M:System.Text.CompositeFormat.get_Format +M:System.Text.CompositeFormat.get_MinimumArgumentCount +M:System.Text.CompositeFormat.Parse(System.String) +M:System.Text.Decoder.#ctor +M:System.Text.Decoder.Convert(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +M:System.Text.Decoder.Convert(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +M:System.Text.Decoder.Convert(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +M:System.Text.Decoder.get_Fallback +M:System.Text.Decoder.get_FallbackBuffer +M:System.Text.Decoder.GetCharCount(System.Byte*,System.Int32,System.Boolean) +M:System.Text.Decoder.GetCharCount(System.Byte[],System.Int32,System.Int32) +M:System.Text.Decoder.GetCharCount(System.Byte[],System.Int32,System.Int32,System.Boolean) +M:System.Text.Decoder.GetCharCount(System.ReadOnlySpan{System.Byte},System.Boolean) +M:System.Text.Decoder.GetChars(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean) +M:System.Text.Decoder.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) +M:System.Text.Decoder.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Boolean) +M:System.Text.Decoder.GetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Boolean) +M:System.Text.Decoder.Reset +M:System.Text.Decoder.set_Fallback(System.Text.DecoderFallback) +M:System.Text.DecoderExceptionFallback.#ctor +M:System.Text.DecoderExceptionFallback.CreateFallbackBuffer +M:System.Text.DecoderExceptionFallback.Equals(System.Object) +M:System.Text.DecoderExceptionFallback.get_MaxCharCount +M:System.Text.DecoderExceptionFallback.GetHashCode +M:System.Text.DecoderExceptionFallbackBuffer.#ctor +M:System.Text.DecoderExceptionFallbackBuffer.Fallback(System.Byte[],System.Int32) +M:System.Text.DecoderExceptionFallbackBuffer.get_Remaining +M:System.Text.DecoderExceptionFallbackBuffer.GetNextChar +M:System.Text.DecoderExceptionFallbackBuffer.MovePrevious +M:System.Text.DecoderFallback.#ctor +M:System.Text.DecoderFallback.CreateFallbackBuffer +M:System.Text.DecoderFallback.get_ExceptionFallback +M:System.Text.DecoderFallback.get_MaxCharCount +M:System.Text.DecoderFallback.get_ReplacementFallback +M:System.Text.DecoderFallbackBuffer.#ctor +M:System.Text.DecoderFallbackBuffer.Fallback(System.Byte[],System.Int32) +M:System.Text.DecoderFallbackBuffer.get_Remaining +M:System.Text.DecoderFallbackBuffer.GetNextChar +M:System.Text.DecoderFallbackBuffer.MovePrevious +M:System.Text.DecoderFallbackBuffer.Reset +M:System.Text.DecoderFallbackException.#ctor +M:System.Text.DecoderFallbackException.#ctor(System.String) +M:System.Text.DecoderFallbackException.#ctor(System.String,System.Byte[],System.Int32) +M:System.Text.DecoderFallbackException.#ctor(System.String,System.Exception) +M:System.Text.DecoderFallbackException.get_BytesUnknown +M:System.Text.DecoderFallbackException.get_Index +M:System.Text.DecoderReplacementFallback.#ctor +M:System.Text.DecoderReplacementFallback.#ctor(System.String) +M:System.Text.DecoderReplacementFallback.CreateFallbackBuffer +M:System.Text.DecoderReplacementFallback.Equals(System.Object) +M:System.Text.DecoderReplacementFallback.get_DefaultString +M:System.Text.DecoderReplacementFallback.get_MaxCharCount +M:System.Text.DecoderReplacementFallback.GetHashCode +M:System.Text.DecoderReplacementFallbackBuffer.#ctor(System.Text.DecoderReplacementFallback) +M:System.Text.DecoderReplacementFallbackBuffer.Fallback(System.Byte[],System.Int32) +M:System.Text.DecoderReplacementFallbackBuffer.get_Remaining +M:System.Text.DecoderReplacementFallbackBuffer.GetNextChar +M:System.Text.DecoderReplacementFallbackBuffer.MovePrevious +M:System.Text.DecoderReplacementFallbackBuffer.Reset +M:System.Text.Encoder.#ctor +M:System.Text.Encoder.Convert(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +M:System.Text.Encoder.Convert(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +M:System.Text.Encoder.Convert(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Boolean,System.Int32@,System.Int32@,System.Boolean@) +M:System.Text.Encoder.get_Fallback +M:System.Text.Encoder.get_FallbackBuffer +M:System.Text.Encoder.GetByteCount(System.Char*,System.Int32,System.Boolean) +M:System.Text.Encoder.GetByteCount(System.Char[],System.Int32,System.Int32,System.Boolean) +M:System.Text.Encoder.GetByteCount(System.ReadOnlySpan{System.Char},System.Boolean) +M:System.Text.Encoder.GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean) +M:System.Text.Encoder.GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Boolean) +M:System.Text.Encoder.GetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Boolean) +M:System.Text.Encoder.Reset +M:System.Text.Encoder.set_Fallback(System.Text.EncoderFallback) +M:System.Text.EncoderExceptionFallback.#ctor +M:System.Text.EncoderExceptionFallback.CreateFallbackBuffer +M:System.Text.EncoderExceptionFallback.Equals(System.Object) +M:System.Text.EncoderExceptionFallback.get_MaxCharCount +M:System.Text.EncoderExceptionFallback.GetHashCode +M:System.Text.EncoderExceptionFallbackBuffer.#ctor +M:System.Text.EncoderExceptionFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) +M:System.Text.EncoderExceptionFallbackBuffer.Fallback(System.Char,System.Int32) +M:System.Text.EncoderExceptionFallbackBuffer.get_Remaining +M:System.Text.EncoderExceptionFallbackBuffer.GetNextChar +M:System.Text.EncoderExceptionFallbackBuffer.MovePrevious +M:System.Text.EncoderFallback.#ctor +M:System.Text.EncoderFallback.CreateFallbackBuffer +M:System.Text.EncoderFallback.get_ExceptionFallback +M:System.Text.EncoderFallback.get_MaxCharCount +M:System.Text.EncoderFallback.get_ReplacementFallback +M:System.Text.EncoderFallbackBuffer.#ctor +M:System.Text.EncoderFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) +M:System.Text.EncoderFallbackBuffer.Fallback(System.Char,System.Int32) +M:System.Text.EncoderFallbackBuffer.get_Remaining +M:System.Text.EncoderFallbackBuffer.GetNextChar +M:System.Text.EncoderFallbackBuffer.MovePrevious +M:System.Text.EncoderFallbackBuffer.Reset +M:System.Text.EncoderFallbackException.#ctor +M:System.Text.EncoderFallbackException.#ctor(System.String) +M:System.Text.EncoderFallbackException.#ctor(System.String,System.Exception) +M:System.Text.EncoderFallbackException.get_CharUnknown +M:System.Text.EncoderFallbackException.get_CharUnknownHigh +M:System.Text.EncoderFallbackException.get_CharUnknownLow +M:System.Text.EncoderFallbackException.get_Index +M:System.Text.EncoderFallbackException.IsUnknownSurrogate +M:System.Text.EncoderReplacementFallback.#ctor +M:System.Text.EncoderReplacementFallback.#ctor(System.String) +M:System.Text.EncoderReplacementFallback.CreateFallbackBuffer +M:System.Text.EncoderReplacementFallback.Equals(System.Object) +M:System.Text.EncoderReplacementFallback.get_DefaultString +M:System.Text.EncoderReplacementFallback.get_MaxCharCount +M:System.Text.EncoderReplacementFallback.GetHashCode +M:System.Text.EncoderReplacementFallbackBuffer.#ctor(System.Text.EncoderReplacementFallback) +M:System.Text.EncoderReplacementFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) +M:System.Text.EncoderReplacementFallbackBuffer.Fallback(System.Char,System.Int32) +M:System.Text.EncoderReplacementFallbackBuffer.get_Remaining +M:System.Text.EncoderReplacementFallbackBuffer.GetNextChar +M:System.Text.EncoderReplacementFallbackBuffer.MovePrevious +M:System.Text.EncoderReplacementFallbackBuffer.Reset +M:System.Text.Encoding.#ctor +M:System.Text.Encoding.#ctor(System.Int32) +M:System.Text.Encoding.#ctor(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) +M:System.Text.Encoding.Clone +M:System.Text.Encoding.Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[]) +M:System.Text.Encoding.Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[],System.Int32,System.Int32) +M:System.Text.Encoding.CreateTranscodingStream(System.IO.Stream,System.Text.Encoding,System.Text.Encoding,System.Boolean) +M:System.Text.Encoding.Equals(System.Object) +M:System.Text.Encoding.get_ASCII +M:System.Text.Encoding.get_BigEndianUnicode +M:System.Text.Encoding.get_BodyName +M:System.Text.Encoding.get_CodePage +M:System.Text.Encoding.get_DecoderFallback +M:System.Text.Encoding.get_Default +M:System.Text.Encoding.get_EncoderFallback +M:System.Text.Encoding.get_EncodingName +M:System.Text.Encoding.get_HeaderName +M:System.Text.Encoding.get_IsBrowserDisplay +M:System.Text.Encoding.get_IsBrowserSave +M:System.Text.Encoding.get_IsMailNewsDisplay +M:System.Text.Encoding.get_IsMailNewsSave +M:System.Text.Encoding.get_IsReadOnly +M:System.Text.Encoding.get_IsSingleByte +M:System.Text.Encoding.get_Latin1 +M:System.Text.Encoding.get_Preamble +M:System.Text.Encoding.get_Unicode +M:System.Text.Encoding.get_UTF32 +M:System.Text.Encoding.get_UTF7 +M:System.Text.Encoding.get_UTF8 +M:System.Text.Encoding.get_WebName +M:System.Text.Encoding.get_WindowsCodePage +M:System.Text.Encoding.GetByteCount(System.Char*,System.Int32) +M:System.Text.Encoding.GetByteCount(System.Char[]) +M:System.Text.Encoding.GetByteCount(System.Char[],System.Int32,System.Int32) +M:System.Text.Encoding.GetByteCount(System.ReadOnlySpan{System.Char}) +M:System.Text.Encoding.GetByteCount(System.String) +M:System.Text.Encoding.GetByteCount(System.String,System.Int32,System.Int32) +M:System.Text.Encoding.GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32) +M:System.Text.Encoding.GetBytes(System.Char[]) +M:System.Text.Encoding.GetBytes(System.Char[],System.Int32,System.Int32) +M:System.Text.Encoding.GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32) +M:System.Text.Encoding.GetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte}) +M:System.Text.Encoding.GetBytes(System.String) +M:System.Text.Encoding.GetBytes(System.String,System.Int32,System.Int32) +M:System.Text.Encoding.GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32) +M:System.Text.Encoding.GetCharCount(System.Byte*,System.Int32) +M:System.Text.Encoding.GetCharCount(System.Byte[]) +M:System.Text.Encoding.GetCharCount(System.Byte[],System.Int32,System.Int32) +M:System.Text.Encoding.GetCharCount(System.ReadOnlySpan{System.Byte}) +M:System.Text.Encoding.GetChars(System.Byte*,System.Int32,System.Char*,System.Int32) +M:System.Text.Encoding.GetChars(System.Byte[]) +M:System.Text.Encoding.GetChars(System.Byte[],System.Int32,System.Int32) +M:System.Text.Encoding.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) +M:System.Text.Encoding.GetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char}) +M:System.Text.Encoding.GetDecoder +M:System.Text.Encoding.GetEncoder +M:System.Text.Encoding.GetEncoding(System.Int32) +M:System.Text.Encoding.GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) +M:System.Text.Encoding.GetEncoding(System.String) +M:System.Text.Encoding.GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback) +M:System.Text.Encoding.GetEncodings +M:System.Text.Encoding.GetHashCode +M:System.Text.Encoding.GetMaxByteCount(System.Int32) +M:System.Text.Encoding.GetMaxCharCount(System.Int32) +M:System.Text.Encoding.GetPreamble +M:System.Text.Encoding.GetString(System.Byte*,System.Int32) +M:System.Text.Encoding.GetString(System.Byte[]) +M:System.Text.Encoding.GetString(System.Byte[],System.Int32,System.Int32) +M:System.Text.Encoding.GetString(System.ReadOnlySpan{System.Byte}) +M:System.Text.Encoding.IsAlwaysNormalized +M:System.Text.Encoding.IsAlwaysNormalized(System.Text.NormalizationForm) +M:System.Text.Encoding.RegisterProvider(System.Text.EncodingProvider) +M:System.Text.Encoding.set_DecoderFallback(System.Text.DecoderFallback) +M:System.Text.Encoding.set_EncoderFallback(System.Text.EncoderFallback) +M:System.Text.Encoding.TryGetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) +M:System.Text.Encoding.TryGetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) +M:System.Text.EncodingInfo.#ctor(System.Text.EncodingProvider,System.Int32,System.String,System.String) +M:System.Text.EncodingInfo.Equals(System.Object) +M:System.Text.EncodingInfo.get_CodePage +M:System.Text.EncodingInfo.get_DisplayName +M:System.Text.EncodingInfo.get_Name +M:System.Text.EncodingInfo.GetEncoding +M:System.Text.EncodingInfo.GetHashCode +M:System.Text.EncodingProvider.#ctor +M:System.Text.EncodingProvider.GetEncoding(System.Int32) +M:System.Text.EncodingProvider.GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) +M:System.Text.EncodingProvider.GetEncoding(System.String) +M:System.Text.EncodingProvider.GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback) +M:System.Text.EncodingProvider.GetEncodings +M:System.Text.Rune.#ctor(System.Char) +M:System.Text.Rune.#ctor(System.Char,System.Char) +M:System.Text.Rune.#ctor(System.Int32) +M:System.Text.Rune.#ctor(System.UInt32) +M:System.Text.Rune.CompareTo(System.Text.Rune) +M:System.Text.Rune.DecodeFromUtf16(System.ReadOnlySpan{System.Char},System.Text.Rune@,System.Int32@) +M:System.Text.Rune.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Text.Rune@,System.Int32@) +M:System.Text.Rune.DecodeLastFromUtf16(System.ReadOnlySpan{System.Char},System.Text.Rune@,System.Int32@) +M:System.Text.Rune.DecodeLastFromUtf8(System.ReadOnlySpan{System.Byte},System.Text.Rune@,System.Int32@) +M:System.Text.Rune.EncodeToUtf16(System.Span{System.Char}) +M:System.Text.Rune.EncodeToUtf8(System.Span{System.Byte}) +M:System.Text.Rune.Equals(System.Object) +M:System.Text.Rune.Equals(System.Text.Rune) +M:System.Text.Rune.get_IsAscii +M:System.Text.Rune.get_IsBmp +M:System.Text.Rune.get_Plane +M:System.Text.Rune.get_ReplacementChar +M:System.Text.Rune.get_Utf16SequenceLength +M:System.Text.Rune.get_Utf8SequenceLength +M:System.Text.Rune.get_Value +M:System.Text.Rune.GetHashCode +M:System.Text.Rune.GetNumericValue(System.Text.Rune) +M:System.Text.Rune.GetRuneAt(System.String,System.Int32) +M:System.Text.Rune.GetUnicodeCategory(System.Text.Rune) +M:System.Text.Rune.IsControl(System.Text.Rune) +M:System.Text.Rune.IsDigit(System.Text.Rune) +M:System.Text.Rune.IsLetter(System.Text.Rune) +M:System.Text.Rune.IsLetterOrDigit(System.Text.Rune) +M:System.Text.Rune.IsLower(System.Text.Rune) +M:System.Text.Rune.IsNumber(System.Text.Rune) +M:System.Text.Rune.IsPunctuation(System.Text.Rune) +M:System.Text.Rune.IsSeparator(System.Text.Rune) +M:System.Text.Rune.IsSymbol(System.Text.Rune) +M:System.Text.Rune.IsUpper(System.Text.Rune) +M:System.Text.Rune.IsValid(System.Int32) +M:System.Text.Rune.IsValid(System.UInt32) +M:System.Text.Rune.IsWhiteSpace(System.Text.Rune) +M:System.Text.Rune.op_Equality(System.Text.Rune,System.Text.Rune) +M:System.Text.Rune.op_Explicit(System.Char)~System.Text.Rune +M:System.Text.Rune.op_Explicit(System.Int32)~System.Text.Rune +M:System.Text.Rune.op_Explicit(System.UInt32)~System.Text.Rune +M:System.Text.Rune.op_GreaterThan(System.Text.Rune,System.Text.Rune) +M:System.Text.Rune.op_GreaterThanOrEqual(System.Text.Rune,System.Text.Rune) +M:System.Text.Rune.op_Inequality(System.Text.Rune,System.Text.Rune) +M:System.Text.Rune.op_LessThan(System.Text.Rune,System.Text.Rune) +M:System.Text.Rune.op_LessThanOrEqual(System.Text.Rune,System.Text.Rune) +M:System.Text.Rune.ToLower(System.Text.Rune,System.Globalization.CultureInfo) +M:System.Text.Rune.ToLowerInvariant(System.Text.Rune) +M:System.Text.Rune.ToString +M:System.Text.Rune.ToUpper(System.Text.Rune,System.Globalization.CultureInfo) +M:System.Text.Rune.ToUpperInvariant(System.Text.Rune) +M:System.Text.Rune.TryCreate(System.Char,System.Char,System.Text.Rune@) +M:System.Text.Rune.TryCreate(System.Char,System.Text.Rune@) +M:System.Text.Rune.TryCreate(System.Int32,System.Text.Rune@) +M:System.Text.Rune.TryCreate(System.UInt32,System.Text.Rune@) +M:System.Text.Rune.TryEncodeToUtf16(System.Span{System.Char},System.Int32@) +M:System.Text.Rune.TryEncodeToUtf8(System.Span{System.Byte},System.Int32@) +M:System.Text.Rune.TryGetRuneAt(System.String,System.Int32,System.Text.Rune@) +M:System.Text.StringBuilder.#ctor +M:System.Text.StringBuilder.#ctor(System.Int32) +M:System.Text.StringBuilder.#ctor(System.Int32,System.Int32) +M:System.Text.StringBuilder.#ctor(System.String) +M:System.Text.StringBuilder.#ctor(System.String,System.Int32) +M:System.Text.StringBuilder.#ctor(System.String,System.Int32,System.Int32,System.Int32) +M:System.Text.StringBuilder.Append(System.Boolean) +M:System.Text.StringBuilder.Append(System.Byte) +M:System.Text.StringBuilder.Append(System.Char) +M:System.Text.StringBuilder.Append(System.Char*,System.Int32) +M:System.Text.StringBuilder.Append(System.Char,System.Int32) +M:System.Text.StringBuilder.Append(System.Char[]) +M:System.Text.StringBuilder.Append(System.Char[],System.Int32,System.Int32) +M:System.Text.StringBuilder.Append(System.Decimal) +M:System.Text.StringBuilder.Append(System.Double) +M:System.Text.StringBuilder.Append(System.IFormatProvider,System.Text.StringBuilder.AppendInterpolatedStringHandler@) +M:System.Text.StringBuilder.Append(System.Int16) +M:System.Text.StringBuilder.Append(System.Int32) +M:System.Text.StringBuilder.Append(System.Int64) +M:System.Text.StringBuilder.Append(System.Object) +M:System.Text.StringBuilder.Append(System.ReadOnlyMemory{System.Char}) +M:System.Text.StringBuilder.Append(System.ReadOnlySpan{System.Char}) +M:System.Text.StringBuilder.Append(System.SByte) +M:System.Text.StringBuilder.Append(System.Single) +M:System.Text.StringBuilder.Append(System.String) +M:System.Text.StringBuilder.Append(System.String,System.Int32,System.Int32) +M:System.Text.StringBuilder.Append(System.Text.StringBuilder) +M:System.Text.StringBuilder.Append(System.Text.StringBuilder,System.Int32,System.Int32) +M:System.Text.StringBuilder.Append(System.Text.StringBuilder.AppendInterpolatedStringHandler@) +M:System.Text.StringBuilder.Append(System.UInt16) +M:System.Text.StringBuilder.Append(System.UInt32) +M:System.Text.StringBuilder.Append(System.UInt64) +M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object) +M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object) +M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) +M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object[]) +M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) +M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) +M:System.Text.StringBuilder.AppendFormat(System.String,System.Object) +M:System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object) +M:System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object,System.Object) +M:System.Text.StringBuilder.AppendFormat(System.String,System.Object[]) +M:System.Text.StringBuilder.AppendFormat``1(System.IFormatProvider,System.Text.CompositeFormat,``0) +M:System.Text.StringBuilder.AppendFormat``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) +M:System.Text.StringBuilder.AppendFormat``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Text.StringBuilder) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Text.StringBuilder,System.IFormatProvider) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.String) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendLiteral(System.String) +M:System.Text.StringBuilder.AppendJoin(System.Char,System.Object[]) +M:System.Text.StringBuilder.AppendJoin(System.Char,System.String[]) +M:System.Text.StringBuilder.AppendJoin(System.String,System.Object[]) +M:System.Text.StringBuilder.AppendJoin(System.String,System.String[]) +M:System.Text.StringBuilder.AppendJoin``1(System.Char,System.Collections.Generic.IEnumerable{``0}) +M:System.Text.StringBuilder.AppendJoin``1(System.String,System.Collections.Generic.IEnumerable{``0}) +M:System.Text.StringBuilder.AppendLine +M:System.Text.StringBuilder.AppendLine(System.IFormatProvider,System.Text.StringBuilder.AppendInterpolatedStringHandler@) +M:System.Text.StringBuilder.AppendLine(System.String) +M:System.Text.StringBuilder.AppendLine(System.Text.StringBuilder.AppendInterpolatedStringHandler@) +M:System.Text.StringBuilder.ChunkEnumerator.get_Current +M:System.Text.StringBuilder.ChunkEnumerator.GetEnumerator +M:System.Text.StringBuilder.ChunkEnumerator.MoveNext +M:System.Text.StringBuilder.Clear +M:System.Text.StringBuilder.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) +M:System.Text.StringBuilder.CopyTo(System.Int32,System.Span{System.Char},System.Int32) +M:System.Text.StringBuilder.EnsureCapacity(System.Int32) +M:System.Text.StringBuilder.Equals(System.ReadOnlySpan{System.Char}) +M:System.Text.StringBuilder.Equals(System.Text.StringBuilder) +M:System.Text.StringBuilder.get_Capacity +M:System.Text.StringBuilder.get_Chars(System.Int32) +M:System.Text.StringBuilder.get_Length +M:System.Text.StringBuilder.get_MaxCapacity +M:System.Text.StringBuilder.GetChunks +M:System.Text.StringBuilder.Insert(System.Int32,System.Boolean) +M:System.Text.StringBuilder.Insert(System.Int32,System.Byte) +M:System.Text.StringBuilder.Insert(System.Int32,System.Char) +M:System.Text.StringBuilder.Insert(System.Int32,System.Char[]) +M:System.Text.StringBuilder.Insert(System.Int32,System.Char[],System.Int32,System.Int32) +M:System.Text.StringBuilder.Insert(System.Int32,System.Decimal) +M:System.Text.StringBuilder.Insert(System.Int32,System.Double) +M:System.Text.StringBuilder.Insert(System.Int32,System.Int16) +M:System.Text.StringBuilder.Insert(System.Int32,System.Int32) +M:System.Text.StringBuilder.Insert(System.Int32,System.Int64) +M:System.Text.StringBuilder.Insert(System.Int32,System.Object) +M:System.Text.StringBuilder.Insert(System.Int32,System.ReadOnlySpan{System.Char}) +M:System.Text.StringBuilder.Insert(System.Int32,System.SByte) +M:System.Text.StringBuilder.Insert(System.Int32,System.Single) +M:System.Text.StringBuilder.Insert(System.Int32,System.String) +M:System.Text.StringBuilder.Insert(System.Int32,System.String,System.Int32) +M:System.Text.StringBuilder.Insert(System.Int32,System.UInt16) +M:System.Text.StringBuilder.Insert(System.Int32,System.UInt32) +M:System.Text.StringBuilder.Insert(System.Int32,System.UInt64) +M:System.Text.StringBuilder.Remove(System.Int32,System.Int32) +M:System.Text.StringBuilder.Replace(System.Char,System.Char) +M:System.Text.StringBuilder.Replace(System.Char,System.Char,System.Int32,System.Int32) +M:System.Text.StringBuilder.Replace(System.String,System.String) +M:System.Text.StringBuilder.Replace(System.String,System.String,System.Int32,System.Int32) +M:System.Text.StringBuilder.set_Capacity(System.Int32) +M:System.Text.StringBuilder.set_Chars(System.Int32,System.Char) +M:System.Text.StringBuilder.set_Length(System.Int32) +M:System.Text.StringBuilder.ToString +M:System.Text.StringBuilder.ToString(System.Int32,System.Int32) +M:System.Text.StringRuneEnumerator.get_Current +M:System.Text.StringRuneEnumerator.GetEnumerator +M:System.Text.StringRuneEnumerator.MoveNext +M:System.Text.Unicode.Utf8.FromUtf16(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean,System.Boolean) +M:System.Text.Unicode.Utf8.IsValid(System.ReadOnlySpan{System.Byte}) +M:System.Text.Unicode.Utf8.ToUtf16(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Int32@,System.Boolean,System.Boolean) +M:System.Text.Unicode.Utf8.TryWrite(System.Span{System.Byte},System.IFormatProvider,System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler@,System.Int32@) +M:System.Text.Unicode.Utf8.TryWrite(System.Span{System.Byte},System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler@,System.Int32@) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Span{System.Byte},System.Boolean@) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Span{System.Byte},System.IFormatProvider,System.Boolean@) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Byte}) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Byte},System.Int32,System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.String) +M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendLiteral(System.String) +M:System.Threading.CancellationToken.#ctor(System.Boolean) +M:System.Threading.CancellationToken.Equals(System.Object) +M:System.Threading.CancellationToken.Equals(System.Threading.CancellationToken) +M:System.Threading.CancellationToken.get_CanBeCanceled +M:System.Threading.CancellationToken.get_IsCancellationRequested +M:System.Threading.CancellationToken.get_None +M:System.Threading.CancellationToken.get_WaitHandle +M:System.Threading.CancellationToken.GetHashCode +M:System.Threading.CancellationToken.op_Equality(System.Threading.CancellationToken,System.Threading.CancellationToken) +M:System.Threading.CancellationToken.op_Inequality(System.Threading.CancellationToken,System.Threading.CancellationToken) +M:System.Threading.CancellationToken.Register(System.Action) +M:System.Threading.CancellationToken.Register(System.Action,System.Boolean) +M:System.Threading.CancellationToken.Register(System.Action{System.Object,System.Threading.CancellationToken},System.Object) +M:System.Threading.CancellationToken.Register(System.Action{System.Object},System.Object) +M:System.Threading.CancellationToken.Register(System.Action{System.Object},System.Object,System.Boolean) +M:System.Threading.CancellationToken.ThrowIfCancellationRequested +M:System.Threading.CancellationToken.UnsafeRegister(System.Action{System.Object,System.Threading.CancellationToken},System.Object) +M:System.Threading.CancellationToken.UnsafeRegister(System.Action{System.Object},System.Object) +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler) +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32) +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32) +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Complete +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_Completion +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_ConcurrentScheduler +M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_ExclusiveScheduler +M:System.Threading.Tasks.Sources.IValueTaskSource.GetResult(System.Int16) +M:System.Threading.Tasks.Sources.IValueTaskSource.GetStatus(System.Int16) +M:System.Threading.Tasks.Sources.IValueTaskSource.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) +M:System.Threading.Tasks.Sources.IValueTaskSource`1.GetResult(System.Int16) +M:System.Threading.Tasks.Sources.IValueTaskSource`1.GetStatus(System.Int16) +M:System.Threading.Tasks.Sources.IValueTaskSource`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.get_RunContinuationsAsynchronously +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.get_Version +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetResult(System.Int16) +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetStatus(System.Int16) +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.Reset +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.set_RunContinuationsAsynchronously(System.Boolean) +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetException(System.Exception) +M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetResult(`0) +M:System.Threading.Tasks.Task.ConfigureAwait(System.Boolean) +M:System.Threading.Tasks.Task.ConfigureAwait(System.Threading.Tasks.ConfigureAwaitOptions) +M:System.Threading.Tasks.Task.Dispose +M:System.Threading.Tasks.Task.Dispose(System.Boolean) +M:System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken) +M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken) +M:System.Threading.Tasks.Task.FromException(System.Exception) +M:System.Threading.Tasks.Task.FromException``1(System.Exception) +M:System.Threading.Tasks.Task.FromResult``1(``0) +M:System.Threading.Tasks.Task.get_AsyncState +M:System.Threading.Tasks.Task.get_CompletedTask +M:System.Threading.Tasks.Task.get_CreationOptions +M:System.Threading.Tasks.Task.get_CurrentId +M:System.Threading.Tasks.Task.get_Exception +M:System.Threading.Tasks.Task.get_Factory +M:System.Threading.Tasks.Task.get_Id +M:System.Threading.Tasks.Task.get_IsCanceled +M:System.Threading.Tasks.Task.get_IsCompleted +M:System.Threading.Tasks.Task.get_IsCompletedSuccessfully +M:System.Threading.Tasks.Task.get_IsFaulted +M:System.Threading.Tasks.Task.get_Status +M:System.Threading.Tasks.Task.GetAwaiter +M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Boolean) +M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Threading.Tasks.ConfigureAwaitOptions) +M:System.Threading.Tasks.Task`1.get_Factory +M:System.Threading.Tasks.Task`1.get_Result +M:System.Threading.Tasks.Task`1.GetAwaiter +M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait(System.IAsyncDisposable,System.Boolean) +M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Boolean) +M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ToBlockingEnumerable``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.WithCancellation``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskCanceledException.#ctor +M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String) +M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception) +M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception,System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Threading.Tasks.Task) +M:System.Threading.Tasks.TaskCanceledException.get_Task +M:System.Threading.Tasks.TaskCompletionSource.#ctor +M:System.Threading.Tasks.TaskCompletionSource.#ctor(System.Object) +M:System.Threading.Tasks.TaskCompletionSource.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions) +M:System.Threading.Tasks.TaskCompletionSource.#ctor(System.Threading.Tasks.TaskCreationOptions) +M:System.Threading.Tasks.TaskCompletionSource.get_Task +M:System.Threading.Tasks.TaskCompletionSource.SetCanceled +M:System.Threading.Tasks.TaskCompletionSource.SetCanceled(System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskCompletionSource.SetException(System.Collections.Generic.IEnumerable{System.Exception}) +M:System.Threading.Tasks.TaskCompletionSource.SetException(System.Exception) +M:System.Threading.Tasks.TaskCompletionSource.SetResult +M:System.Threading.Tasks.TaskCompletionSource.TrySetCanceled +M:System.Threading.Tasks.TaskCompletionSource.TrySetCanceled(System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) +M:System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Exception) +M:System.Threading.Tasks.TaskCompletionSource.TrySetResult +M:System.Threading.Tasks.TaskCompletionSource`1.#ctor +M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object) +M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions) +M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Threading.Tasks.TaskCreationOptions) +M:System.Threading.Tasks.TaskCompletionSource`1.get_Task +M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled +M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled(System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception}) +M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception) +M:System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0) +M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled +M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken) +M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) +M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception) +M:System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0) +M:System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task}) +M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}}) +M:System.Threading.Tasks.TaskSchedulerException.#ctor +M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Exception) +M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String) +M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String,System.Exception) +M:System.Threading.Tasks.TaskToAsyncResult.Begin(System.Threading.Tasks.Task,System.AsyncCallback,System.Object) +M:System.Threading.Tasks.TaskToAsyncResult.End(System.IAsyncResult) +M:System.Threading.Tasks.TaskToAsyncResult.End``1(System.IAsyncResult) +M:System.Threading.Tasks.TaskToAsyncResult.Unwrap(System.IAsyncResult) +M:System.Threading.Tasks.TaskToAsyncResult.Unwrap``1(System.IAsyncResult) +M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.#ctor(System.AggregateException) +M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.get_Exception +M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.get_Observed +M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.SetObserved +M:System.Threading.Tasks.ValueTask.#ctor(System.Threading.Tasks.Sources.IValueTaskSource,System.Int16) +M:System.Threading.Tasks.ValueTask.#ctor(System.Threading.Tasks.Task) +M:System.Threading.Tasks.ValueTask.AsTask +M:System.Threading.Tasks.ValueTask.ConfigureAwait(System.Boolean) +M:System.Threading.Tasks.ValueTask.Equals(System.Object) +M:System.Threading.Tasks.ValueTask.Equals(System.Threading.Tasks.ValueTask) +M:System.Threading.Tasks.ValueTask.FromCanceled(System.Threading.CancellationToken) +M:System.Threading.Tasks.ValueTask.FromCanceled``1(System.Threading.CancellationToken) +M:System.Threading.Tasks.ValueTask.FromException(System.Exception) +M:System.Threading.Tasks.ValueTask.FromException``1(System.Exception) +M:System.Threading.Tasks.ValueTask.FromResult``1(``0) +M:System.Threading.Tasks.ValueTask.get_CompletedTask +M:System.Threading.Tasks.ValueTask.get_IsCanceled +M:System.Threading.Tasks.ValueTask.get_IsCompleted +M:System.Threading.Tasks.ValueTask.get_IsCompletedSuccessfully +M:System.Threading.Tasks.ValueTask.get_IsFaulted +M:System.Threading.Tasks.ValueTask.GetAwaiter +M:System.Threading.Tasks.ValueTask.GetHashCode +M:System.Threading.Tasks.ValueTask.op_Equality(System.Threading.Tasks.ValueTask,System.Threading.Tasks.ValueTask) +M:System.Threading.Tasks.ValueTask.op_Inequality(System.Threading.Tasks.ValueTask,System.Threading.Tasks.ValueTask) +M:System.Threading.Tasks.ValueTask.Preserve +M:System.Threading.Tasks.ValueTask`1.#ctor(`0) +M:System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Sources.IValueTaskSource{`0},System.Int16) +M:System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Task{`0}) +M:System.Threading.Tasks.ValueTask`1.AsTask +M:System.Threading.Tasks.ValueTask`1.ConfigureAwait(System.Boolean) +M:System.Threading.Tasks.ValueTask`1.Equals(System.Object) +M:System.Threading.Tasks.ValueTask`1.Equals(System.Threading.Tasks.ValueTask{`0}) +M:System.Threading.Tasks.ValueTask`1.get_IsCanceled +M:System.Threading.Tasks.ValueTask`1.get_IsCompleted +M:System.Threading.Tasks.ValueTask`1.get_IsCompletedSuccessfully +M:System.Threading.Tasks.ValueTask`1.get_IsFaulted +M:System.Threading.Tasks.ValueTask`1.get_Result +M:System.Threading.Tasks.ValueTask`1.GetAwaiter +M:System.Threading.Tasks.ValueTask`1.GetHashCode +M:System.Threading.Tasks.ValueTask`1.op_Equality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0}) +M:System.Threading.Tasks.ValueTask`1.op_Inequality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0}) +M:System.Threading.Tasks.ValueTask`1.Preserve +M:System.Threading.Tasks.ValueTask`1.ToString +M:System.TimeOnly.#ctor(System.Int32,System.Int32) +M:System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32) +M:System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.TimeOnly.#ctor(System.Int64) +M:System.TimeOnly.Add(System.TimeSpan) +M:System.TimeOnly.Add(System.TimeSpan,System.Int32@) +M:System.TimeOnly.AddHours(System.Double) +M:System.TimeOnly.AddHours(System.Double,System.Int32@) +M:System.TimeOnly.AddMinutes(System.Double) +M:System.TimeOnly.AddMinutes(System.Double,System.Int32@) +M:System.TimeOnly.CompareTo(System.Object) +M:System.TimeOnly.CompareTo(System.TimeOnly) +M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@) +M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@) +M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@,System.Int32@) +M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@,System.Int32@,System.Int32@) +M:System.TimeOnly.Equals(System.Object) +M:System.TimeOnly.Equals(System.TimeOnly) +M:System.TimeOnly.FromDateTime(System.DateTime) +M:System.TimeOnly.FromTimeSpan(System.TimeSpan) +M:System.TimeOnly.get_Hour +M:System.TimeOnly.get_MaxValue +M:System.TimeOnly.get_Microsecond +M:System.TimeOnly.get_Millisecond +M:System.TimeOnly.get_Minute +M:System.TimeOnly.get_MinValue +M:System.TimeOnly.get_Nanosecond +M:System.TimeOnly.get_Second +M:System.TimeOnly.get_Ticks +M:System.TimeOnly.GetHashCode +M:System.TimeOnly.IsBetween(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_Equality(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_GreaterThan(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_GreaterThanOrEqual(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_Inequality(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_LessThan(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_LessThanOrEqual(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.op_Subtraction(System.TimeOnly,System.TimeOnly) +M:System.TimeOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.TimeOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.TimeOnly.Parse(System.String) +M:System.TimeOnly.Parse(System.String,System.IFormatProvider) +M:System.TimeOnly.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[]) +M:System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.TimeOnly.ParseExact(System.String,System.String) +M:System.TimeOnly.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.TimeOnly.ParseExact(System.String,System.String[]) +M:System.TimeOnly.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) +M:System.TimeOnly.ToLongTimeString +M:System.TimeOnly.ToShortTimeString +M:System.TimeOnly.ToString +M:System.TimeOnly.ToString(System.IFormatProvider) +M:System.TimeOnly.ToString(System.String) +M:System.TimeOnly.ToString(System.String,System.IFormatProvider) +M:System.TimeOnly.ToTimeSpan +M:System.TimeOnly.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.TimeOnly.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +M:System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeOnly@) +M:System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.TimeOnly@) +M:System.TimeOnly.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +M:System.TimeOnly.TryParse(System.String,System.IFormatProvider,System.TimeOnly@) +M:System.TimeOnly.TryParse(System.String,System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.String,System.String,System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) +M:System.TimeOnly.TryParseExact(System.String,System.String[],System.TimeOnly@) +M:System.TimeoutException.#ctor +M:System.TimeoutException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TimeoutException.#ctor(System.String) +M:System.TimeoutException.#ctor(System.String,System.Exception) +M:System.TimeProvider.#ctor +M:System.TimeProvider.CreateTimer(System.Threading.TimerCallback,System.Object,System.TimeSpan,System.TimeSpan) +M:System.TimeProvider.get_LocalTimeZone +M:System.TimeProvider.get_System +M:System.TimeProvider.get_TimestampFrequency +M:System.TimeProvider.GetElapsedTime(System.Int64) +M:System.TimeProvider.GetElapsedTime(System.Int64,System.Int64) +M:System.TimeProvider.GetLocalNow +M:System.TimeProvider.GetTimestamp +M:System.TimeProvider.GetUtcNow +M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32) +M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) +M:System.TimeSpan.#ctor(System.Int64) +M:System.TimeSpan.Add(System.TimeSpan) +M:System.TimeSpan.Compare(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.CompareTo(System.Object) +M:System.TimeSpan.CompareTo(System.TimeSpan) +M:System.TimeSpan.Divide(System.Double) +M:System.TimeSpan.Divide(System.TimeSpan) +M:System.TimeSpan.Duration +M:System.TimeSpan.Equals(System.Object) +M:System.TimeSpan.Equals(System.TimeSpan) +M:System.TimeSpan.Equals(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.FromDays(System.Double) +M:System.TimeSpan.FromHours(System.Double) +M:System.TimeSpan.FromMicroseconds(System.Double) +M:System.TimeSpan.FromMilliseconds(System.Double) +M:System.TimeSpan.FromMinutes(System.Double) +M:System.TimeSpan.FromSeconds(System.Double) +M:System.TimeSpan.FromTicks(System.Int64) +M:System.TimeSpan.get_Days +M:System.TimeSpan.get_Hours +M:System.TimeSpan.get_Microseconds +M:System.TimeSpan.get_Milliseconds +M:System.TimeSpan.get_Minutes +M:System.TimeSpan.get_Nanoseconds +M:System.TimeSpan.get_Seconds +M:System.TimeSpan.get_Ticks +M:System.TimeSpan.get_TotalDays +M:System.TimeSpan.get_TotalHours +M:System.TimeSpan.get_TotalMicroseconds +M:System.TimeSpan.get_TotalMilliseconds +M:System.TimeSpan.get_TotalMinutes +M:System.TimeSpan.get_TotalNanoseconds +M:System.TimeSpan.get_TotalSeconds +M:System.TimeSpan.GetHashCode +M:System.TimeSpan.Multiply(System.Double) +M:System.TimeSpan.Negate +M:System.TimeSpan.op_Addition(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_Division(System.TimeSpan,System.Double) +M:System.TimeSpan.op_Division(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_Equality(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_GreaterThan(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_GreaterThanOrEqual(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_Inequality(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_LessThan(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_LessThanOrEqual(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_Multiply(System.Double,System.TimeSpan) +M:System.TimeSpan.op_Multiply(System.TimeSpan,System.Double) +M:System.TimeSpan.op_Subtraction(System.TimeSpan,System.TimeSpan) +M:System.TimeSpan.op_UnaryNegation(System.TimeSpan) +M:System.TimeSpan.op_UnaryPlus(System.TimeSpan) +M:System.TimeSpan.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.TimeSpan.Parse(System.String) +M:System.TimeSpan.Parse(System.String,System.IFormatProvider) +M:System.TimeSpan.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.TimeSpanStyles) +M:System.TimeSpan.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) +M:System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider) +M:System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles) +M:System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider) +M:System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) +M:System.TimeSpan.Subtract(System.TimeSpan) +M:System.TimeSpan.ToString +M:System.TimeSpan.ToString(System.String) +M:System.TimeSpan.ToString(System.String,System.IFormatProvider) +M:System.TimeSpan.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.TimeSpan.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.TimeSpan.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeSpan@) +M:System.TimeSpan.TryParse(System.ReadOnlySpan{System.Char},System.TimeSpan@) +M:System.TimeSpan.TryParse(System.String,System.IFormatProvider,System.TimeSpan@) +M:System.TimeSpan.TryParse(System.String,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.String,System.String,System.IFormatProvider,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) +M:System.TimeSpan.TryParseExact(System.String,System.String[],System.IFormatProvider,System.TimeSpan@) +M:System.TimeZone.#ctor +M:System.TimeZone.get_CurrentTimeZone +M:System.TimeZone.get_DaylightName +M:System.TimeZone.get_StandardName +M:System.TimeZone.GetDaylightChanges(System.Int32) +M:System.TimeZone.GetUtcOffset(System.DateTime) +M:System.TimeZone.IsDaylightSavingTime(System.DateTime) +M:System.TimeZone.IsDaylightSavingTime(System.DateTime,System.Globalization.DaylightTime) +M:System.TimeZone.ToLocalTime(System.DateTime) +M:System.TimeZone.ToUniversalTime(System.DateTime) +M:System.TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) +M:System.TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime,System.TimeSpan) +M:System.TimeZoneInfo.AdjustmentRule.Equals(System.Object) +M:System.TimeZoneInfo.AdjustmentRule.Equals(System.TimeZoneInfo.AdjustmentRule) +M:System.TimeZoneInfo.AdjustmentRule.get_BaseUtcOffsetDelta +M:System.TimeZoneInfo.AdjustmentRule.get_DateEnd +M:System.TimeZoneInfo.AdjustmentRule.get_DateStart +M:System.TimeZoneInfo.AdjustmentRule.get_DaylightDelta +M:System.TimeZoneInfo.AdjustmentRule.get_DaylightTransitionEnd +M:System.TimeZoneInfo.AdjustmentRule.get_DaylightTransitionStart +M:System.TimeZoneInfo.AdjustmentRule.GetHashCode +M:System.TimeZoneInfo.ClearCachedData +M:System.TimeZoneInfo.ConvertTime(System.DateTime,System.TimeZoneInfo) +M:System.TimeZoneInfo.ConvertTime(System.DateTime,System.TimeZoneInfo,System.TimeZoneInfo) +M:System.TimeZoneInfo.ConvertTime(System.DateTimeOffset,System.TimeZoneInfo) +M:System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTime,System.String) +M:System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTime,System.String,System.String) +M:System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTimeOffset,System.String) +M:System.TimeZoneInfo.ConvertTimeFromUtc(System.DateTime,System.TimeZoneInfo) +M:System.TimeZoneInfo.ConvertTimeToUtc(System.DateTime) +M:System.TimeZoneInfo.ConvertTimeToUtc(System.DateTime,System.TimeZoneInfo) +M:System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String) +M:System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo.AdjustmentRule[]) +M:System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo.AdjustmentRule[],System.Boolean) +M:System.TimeZoneInfo.Equals(System.Object) +M:System.TimeZoneInfo.Equals(System.TimeZoneInfo) +M:System.TimeZoneInfo.FindSystemTimeZoneById(System.String) +M:System.TimeZoneInfo.FromSerializedString(System.String) +M:System.TimeZoneInfo.get_BaseUtcOffset +M:System.TimeZoneInfo.get_DaylightName +M:System.TimeZoneInfo.get_DisplayName +M:System.TimeZoneInfo.get_HasIanaId +M:System.TimeZoneInfo.get_Id +M:System.TimeZoneInfo.get_Local +M:System.TimeZoneInfo.get_StandardName +M:System.TimeZoneInfo.get_SupportsDaylightSavingTime +M:System.TimeZoneInfo.get_Utc +M:System.TimeZoneInfo.GetAdjustmentRules +M:System.TimeZoneInfo.GetAmbiguousTimeOffsets(System.DateTime) +M:System.TimeZoneInfo.GetAmbiguousTimeOffsets(System.DateTimeOffset) +M:System.TimeZoneInfo.GetHashCode +M:System.TimeZoneInfo.GetSystemTimeZones +M:System.TimeZoneInfo.GetSystemTimeZones(System.Boolean) +M:System.TimeZoneInfo.GetUtcOffset(System.DateTime) +M:System.TimeZoneInfo.GetUtcOffset(System.DateTimeOffset) +M:System.TimeZoneInfo.HasSameRules(System.TimeZoneInfo) +M:System.TimeZoneInfo.IsAmbiguousTime(System.DateTime) +M:System.TimeZoneInfo.IsAmbiguousTime(System.DateTimeOffset) +M:System.TimeZoneInfo.IsDaylightSavingTime(System.DateTime) +M:System.TimeZoneInfo.IsDaylightSavingTime(System.DateTimeOffset) +M:System.TimeZoneInfo.IsInvalidTime(System.DateTime) +M:System.TimeZoneInfo.ToSerializedString +M:System.TimeZoneInfo.ToString +M:System.TimeZoneInfo.TransitionTime.CreateFixedDateRule(System.DateTime,System.Int32,System.Int32) +M:System.TimeZoneInfo.TransitionTime.CreateFloatingDateRule(System.DateTime,System.Int32,System.Int32,System.DayOfWeek) +M:System.TimeZoneInfo.TransitionTime.Equals(System.Object) +M:System.TimeZoneInfo.TransitionTime.Equals(System.TimeZoneInfo.TransitionTime) +M:System.TimeZoneInfo.TransitionTime.get_Day +M:System.TimeZoneInfo.TransitionTime.get_DayOfWeek +M:System.TimeZoneInfo.TransitionTime.get_IsFixedDateRule +M:System.TimeZoneInfo.TransitionTime.get_Month +M:System.TimeZoneInfo.TransitionTime.get_TimeOfDay +M:System.TimeZoneInfo.TransitionTime.get_Week +M:System.TimeZoneInfo.TransitionTime.GetHashCode +M:System.TimeZoneInfo.TransitionTime.op_Equality(System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) +M:System.TimeZoneInfo.TransitionTime.op_Inequality(System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) +M:System.TimeZoneInfo.TryConvertIanaIdToWindowsId(System.String,System.String@) +M:System.TimeZoneInfo.TryConvertWindowsIdToIanaId(System.String,System.String,System.String@) +M:System.TimeZoneInfo.TryConvertWindowsIdToIanaId(System.String,System.String@) +M:System.TimeZoneInfo.TryFindSystemTimeZoneById(System.String,System.TimeZoneInfo@) +M:System.TimeZoneNotFoundException.#ctor +M:System.TimeZoneNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TimeZoneNotFoundException.#ctor(System.String) +M:System.TimeZoneNotFoundException.#ctor(System.String,System.Exception) +M:System.Tuple.Create``1(``0) +M:System.Tuple.Create``2(``0,``1) +M:System.Tuple.Create``3(``0,``1,``2) +M:System.Tuple.Create``4(``0,``1,``2,``3) +M:System.Tuple.Create``5(``0,``1,``2,``3,``4) +M:System.Tuple.Create``6(``0,``1,``2,``3,``4,``5) +M:System.Tuple.Create``7(``0,``1,``2,``3,``4,``5,``6) +M:System.Tuple.Create``8(``0,``1,``2,``3,``4,``5,``6,``7) +M:System.Tuple`1.#ctor(`0) +M:System.Tuple`1.Equals(System.Object) +M:System.Tuple`1.get_Item1 +M:System.Tuple`1.GetHashCode +M:System.Tuple`1.ToString +M:System.Tuple`2.#ctor(`0,`1) +M:System.Tuple`2.Equals(System.Object) +M:System.Tuple`2.get_Item1 +M:System.Tuple`2.get_Item2 +M:System.Tuple`2.GetHashCode +M:System.Tuple`2.ToString +M:System.Tuple`3.#ctor(`0,`1,`2) +M:System.Tuple`3.Equals(System.Object) +M:System.Tuple`3.get_Item1 +M:System.Tuple`3.get_Item2 +M:System.Tuple`3.get_Item3 +M:System.Tuple`3.GetHashCode +M:System.Tuple`3.ToString +M:System.Tuple`4.#ctor(`0,`1,`2,`3) +M:System.Tuple`4.Equals(System.Object) +M:System.Tuple`4.get_Item1 +M:System.Tuple`4.get_Item2 +M:System.Tuple`4.get_Item3 +M:System.Tuple`4.get_Item4 +M:System.Tuple`4.GetHashCode +M:System.Tuple`4.ToString +M:System.Tuple`5.#ctor(`0,`1,`2,`3,`4) +M:System.Tuple`5.Equals(System.Object) +M:System.Tuple`5.get_Item1 +M:System.Tuple`5.get_Item2 +M:System.Tuple`5.get_Item3 +M:System.Tuple`5.get_Item4 +M:System.Tuple`5.get_Item5 +M:System.Tuple`5.GetHashCode +M:System.Tuple`5.ToString +M:System.Tuple`6.#ctor(`0,`1,`2,`3,`4,`5) +M:System.Tuple`6.Equals(System.Object) +M:System.Tuple`6.get_Item1 +M:System.Tuple`6.get_Item2 +M:System.Tuple`6.get_Item3 +M:System.Tuple`6.get_Item4 +M:System.Tuple`6.get_Item5 +M:System.Tuple`6.get_Item6 +M:System.Tuple`6.GetHashCode +M:System.Tuple`6.ToString +M:System.Tuple`7.#ctor(`0,`1,`2,`3,`4,`5,`6) +M:System.Tuple`7.Equals(System.Object) +M:System.Tuple`7.get_Item1 +M:System.Tuple`7.get_Item2 +M:System.Tuple`7.get_Item3 +M:System.Tuple`7.get_Item4 +M:System.Tuple`7.get_Item5 +M:System.Tuple`7.get_Item6 +M:System.Tuple`7.get_Item7 +M:System.Tuple`7.GetHashCode +M:System.Tuple`7.ToString +M:System.Tuple`8.#ctor(`0,`1,`2,`3,`4,`5,`6,`7) +M:System.Tuple`8.Equals(System.Object) +M:System.Tuple`8.get_Item1 +M:System.Tuple`8.get_Item2 +M:System.Tuple`8.get_Item3 +M:System.Tuple`8.get_Item4 +M:System.Tuple`8.get_Item5 +M:System.Tuple`8.get_Item6 +M:System.Tuple`8.get_Item7 +M:System.Tuple`8.get_Rest +M:System.Tuple`8.GetHashCode +M:System.Tuple`8.ToString +M:System.TupleExtensions.Deconstruct``1(System.Tuple{``0},``0@) +M:System.TupleExtensions.Deconstruct``10(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@) +M:System.TupleExtensions.Deconstruct``11(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@) +M:System.TupleExtensions.Deconstruct``12(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@) +M:System.TupleExtensions.Deconstruct``13(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@) +M:System.TupleExtensions.Deconstruct``14(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@) +M:System.TupleExtensions.Deconstruct``15(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@) +M:System.TupleExtensions.Deconstruct``16(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@) +M:System.TupleExtensions.Deconstruct``17(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@) +M:System.TupleExtensions.Deconstruct``18(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@) +M:System.TupleExtensions.Deconstruct``19(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@) +M:System.TupleExtensions.Deconstruct``2(System.Tuple{``0,``1},``0@,``1@) +M:System.TupleExtensions.Deconstruct``20(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@,``19@) +M:System.TupleExtensions.Deconstruct``21(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19,``20}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@,``19@,``20@) +M:System.TupleExtensions.Deconstruct``3(System.Tuple{``0,``1,``2},``0@,``1@,``2@) +M:System.TupleExtensions.Deconstruct``4(System.Tuple{``0,``1,``2,``3},``0@,``1@,``2@,``3@) +M:System.TupleExtensions.Deconstruct``5(System.Tuple{``0,``1,``2,``3,``4},``0@,``1@,``2@,``3@,``4@) +M:System.TupleExtensions.Deconstruct``6(System.Tuple{``0,``1,``2,``3,``4,``5},``0@,``1@,``2@,``3@,``4@,``5@) +M:System.TupleExtensions.Deconstruct``7(System.Tuple{``0,``1,``2,``3,``4,``5,``6},``0@,``1@,``2@,``3@,``4@,``5@,``6@) +M:System.TupleExtensions.Deconstruct``8(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@) +M:System.TupleExtensions.Deconstruct``9(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@) +M:System.TupleExtensions.ToTuple``1(System.ValueTuple{``0}) +M:System.TupleExtensions.ToTuple``10(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9}}) +M:System.TupleExtensions.ToTuple``11(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10}}) +M:System.TupleExtensions.ToTuple``12(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11}}) +M:System.TupleExtensions.ToTuple``13(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12}}) +M:System.TupleExtensions.ToTuple``14(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13}}) +M:System.TupleExtensions.ToTuple``15(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14}}}) +M:System.TupleExtensions.ToTuple``16(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15}}}) +M:System.TupleExtensions.ToTuple``17(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16}}}) +M:System.TupleExtensions.ToTuple``18(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17}}}) +M:System.TupleExtensions.ToTuple``19(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18}}}) +M:System.TupleExtensions.ToTuple``2(System.ValueTuple{``0,``1}) +M:System.TupleExtensions.ToTuple``20(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18,``19}}}) +M:System.TupleExtensions.ToTuple``21(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18,``19,``20}}}) +M:System.TupleExtensions.ToTuple``3(System.ValueTuple{``0,``1,``2}) +M:System.TupleExtensions.ToTuple``4(System.ValueTuple{``0,``1,``2,``3}) +M:System.TupleExtensions.ToTuple``5(System.ValueTuple{``0,``1,``2,``3,``4}) +M:System.TupleExtensions.ToTuple``6(System.ValueTuple{``0,``1,``2,``3,``4,``5}) +M:System.TupleExtensions.ToTuple``7(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6}) +M:System.TupleExtensions.ToTuple``8(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7}}) +M:System.TupleExtensions.ToTuple``9(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8}}) +M:System.TupleExtensions.ToValueTuple``1(System.Tuple{``0}) +M:System.TupleExtensions.ToValueTuple``10(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9}}) +M:System.TupleExtensions.ToValueTuple``11(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10}}) +M:System.TupleExtensions.ToValueTuple``12(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11}}) +M:System.TupleExtensions.ToValueTuple``13(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12}}) +M:System.TupleExtensions.ToValueTuple``14(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13}}) +M:System.TupleExtensions.ToValueTuple``15(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14}}}) +M:System.TupleExtensions.ToValueTuple``16(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15}}}) +M:System.TupleExtensions.ToValueTuple``17(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16}}}) +M:System.TupleExtensions.ToValueTuple``18(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17}}}) +M:System.TupleExtensions.ToValueTuple``19(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18}}}) +M:System.TupleExtensions.ToValueTuple``2(System.Tuple{``0,``1}) +M:System.TupleExtensions.ToValueTuple``20(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19}}}) +M:System.TupleExtensions.ToValueTuple``21(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19,``20}}}) +M:System.TupleExtensions.ToValueTuple``3(System.Tuple{``0,``1,``2}) +M:System.TupleExtensions.ToValueTuple``4(System.Tuple{``0,``1,``2,``3}) +M:System.TupleExtensions.ToValueTuple``5(System.Tuple{``0,``1,``2,``3,``4}) +M:System.TupleExtensions.ToValueTuple``6(System.Tuple{``0,``1,``2,``3,``4,``5}) +M:System.TupleExtensions.ToValueTuple``7(System.Tuple{``0,``1,``2,``3,``4,``5,``6}) +M:System.TupleExtensions.ToValueTuple``8(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7}}) +M:System.TupleExtensions.ToValueTuple``9(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8}}) +M:System.TypeAccessException.#ctor +M:System.TypeAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TypeAccessException.#ctor(System.String) +M:System.TypeAccessException.#ctor(System.String,System.Exception) +M:System.TypedReference.Equals(System.Object) +M:System.TypedReference.GetHashCode +M:System.TypedReference.GetTargetType(System.TypedReference) +M:System.TypedReference.MakeTypedReference(System.Object,System.Reflection.FieldInfo[]) +M:System.TypedReference.SetTypedReference(System.TypedReference,System.Object) +M:System.TypedReference.TargetTypeToken(System.TypedReference) +M:System.TypedReference.ToObject(System.TypedReference) +M:System.TypeInitializationException.#ctor(System.String,System.Exception) +M:System.TypeInitializationException.get_TypeName +M:System.TypeInitializationException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TypeLoadException.#ctor +M:System.TypeLoadException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TypeLoadException.#ctor(System.String) +M:System.TypeLoadException.#ctor(System.String,System.Exception) +M:System.TypeLoadException.get_Message +M:System.TypeLoadException.get_TypeName +M:System.TypeLoadException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TypeUnloadedException.#ctor +M:System.TypeUnloadedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.TypeUnloadedException.#ctor(System.String) +M:System.TypeUnloadedException.#ctor(System.String,System.Exception) +M:System.UInt128.#ctor(System.UInt64,System.UInt64) +M:System.UInt128.Clamp(System.UInt128,System.UInt128,System.UInt128) +M:System.UInt128.CompareTo(System.Object) +M:System.UInt128.CompareTo(System.UInt128) +M:System.UInt128.CreateChecked``1(``0) +M:System.UInt128.CreateSaturating``1(``0) +M:System.UInt128.CreateTruncating``1(``0) +M:System.UInt128.DivRem(System.UInt128,System.UInt128) +M:System.UInt128.Equals(System.Object) +M:System.UInt128.Equals(System.UInt128) +M:System.UInt128.get_MaxValue +M:System.UInt128.get_MinValue +M:System.UInt128.get_One +M:System.UInt128.get_Zero +M:System.UInt128.GetHashCode +M:System.UInt128.IsEvenInteger(System.UInt128) +M:System.UInt128.IsOddInteger(System.UInt128) +M:System.UInt128.IsPow2(System.UInt128) +M:System.UInt128.LeadingZeroCount(System.UInt128) +M:System.UInt128.Log2(System.UInt128) +M:System.UInt128.Max(System.UInt128,System.UInt128) +M:System.UInt128.Min(System.UInt128,System.UInt128) +M:System.UInt128.op_Addition(System.UInt128,System.UInt128) +M:System.UInt128.op_BitwiseAnd(System.UInt128,System.UInt128) +M:System.UInt128.op_BitwiseOr(System.UInt128,System.UInt128) +M:System.UInt128.op_CheckedAddition(System.UInt128,System.UInt128) +M:System.UInt128.op_CheckedDecrement(System.UInt128) +M:System.UInt128.op_CheckedDivision(System.UInt128,System.UInt128) +M:System.UInt128.op_CheckedExplicit(System.Double)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.Int16)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.Int32)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.Int64)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.IntPtr)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.SByte)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.Single)~System.UInt128 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Byte +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Char +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int128 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int16 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int32 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int64 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.IntPtr +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.SByte +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt16 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt32 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt64 +M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UIntPtr +M:System.UInt128.op_CheckedIncrement(System.UInt128) +M:System.UInt128.op_CheckedMultiply(System.UInt128,System.UInt128) +M:System.UInt128.op_CheckedSubtraction(System.UInt128,System.UInt128) +M:System.UInt128.op_CheckedUnaryNegation(System.UInt128) +M:System.UInt128.op_Decrement(System.UInt128) +M:System.UInt128.op_Division(System.UInt128,System.UInt128) +M:System.UInt128.op_Equality(System.UInt128,System.UInt128) +M:System.UInt128.op_ExclusiveOr(System.UInt128,System.UInt128) +M:System.UInt128.op_Explicit(System.Decimal)~System.UInt128 +M:System.UInt128.op_Explicit(System.Double)~System.UInt128 +M:System.UInt128.op_Explicit(System.Int16)~System.UInt128 +M:System.UInt128.op_Explicit(System.Int32)~System.UInt128 +M:System.UInt128.op_Explicit(System.Int64)~System.UInt128 +M:System.UInt128.op_Explicit(System.IntPtr)~System.UInt128 +M:System.UInt128.op_Explicit(System.SByte)~System.UInt128 +M:System.UInt128.op_Explicit(System.Single)~System.UInt128 +M:System.UInt128.op_Explicit(System.UInt128)~System.Byte +M:System.UInt128.op_Explicit(System.UInt128)~System.Char +M:System.UInt128.op_Explicit(System.UInt128)~System.Decimal +M:System.UInt128.op_Explicit(System.UInt128)~System.Double +M:System.UInt128.op_Explicit(System.UInt128)~System.Half +M:System.UInt128.op_Explicit(System.UInt128)~System.Int128 +M:System.UInt128.op_Explicit(System.UInt128)~System.Int16 +M:System.UInt128.op_Explicit(System.UInt128)~System.Int32 +M:System.UInt128.op_Explicit(System.UInt128)~System.Int64 +M:System.UInt128.op_Explicit(System.UInt128)~System.IntPtr +M:System.UInt128.op_Explicit(System.UInt128)~System.SByte +M:System.UInt128.op_Explicit(System.UInt128)~System.Single +M:System.UInt128.op_Explicit(System.UInt128)~System.UInt16 +M:System.UInt128.op_Explicit(System.UInt128)~System.UInt32 +M:System.UInt128.op_Explicit(System.UInt128)~System.UInt64 +M:System.UInt128.op_Explicit(System.UInt128)~System.UIntPtr +M:System.UInt128.op_GreaterThan(System.UInt128,System.UInt128) +M:System.UInt128.op_GreaterThanOrEqual(System.UInt128,System.UInt128) +M:System.UInt128.op_Implicit(System.Byte)~System.UInt128 +M:System.UInt128.op_Implicit(System.Char)~System.UInt128 +M:System.UInt128.op_Implicit(System.UInt16)~System.UInt128 +M:System.UInt128.op_Implicit(System.UInt32)~System.UInt128 +M:System.UInt128.op_Implicit(System.UInt64)~System.UInt128 +M:System.UInt128.op_Implicit(System.UIntPtr)~System.UInt128 +M:System.UInt128.op_Increment(System.UInt128) +M:System.UInt128.op_Inequality(System.UInt128,System.UInt128) +M:System.UInt128.op_LeftShift(System.UInt128,System.Int32) +M:System.UInt128.op_LessThan(System.UInt128,System.UInt128) +M:System.UInt128.op_LessThanOrEqual(System.UInt128,System.UInt128) +M:System.UInt128.op_Modulus(System.UInt128,System.UInt128) +M:System.UInt128.op_Multiply(System.UInt128,System.UInt128) +M:System.UInt128.op_OnesComplement(System.UInt128) +M:System.UInt128.op_RightShift(System.UInt128,System.Int32) +M:System.UInt128.op_Subtraction(System.UInt128,System.UInt128) +M:System.UInt128.op_UnaryNegation(System.UInt128) +M:System.UInt128.op_UnaryPlus(System.UInt128) +M:System.UInt128.op_UnsignedRightShift(System.UInt128,System.Int32) +M:System.UInt128.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt128.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.UInt128.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt128.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt128.Parse(System.String) +M:System.UInt128.Parse(System.String,System.Globalization.NumberStyles) +M:System.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt128.Parse(System.String,System.IFormatProvider) +M:System.UInt128.PopCount(System.UInt128) +M:System.UInt128.RotateLeft(System.UInt128,System.Int32) +M:System.UInt128.RotateRight(System.UInt128,System.Int32) +M:System.UInt128.Sign(System.UInt128) +M:System.UInt128.ToString +M:System.UInt128.ToString(System.IFormatProvider) +M:System.UInt128.ToString(System.String) +M:System.UInt128.ToString(System.String,System.IFormatProvider) +M:System.UInt128.TrailingZeroCount(System.UInt128) +M:System.UInt128.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt128.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) +M:System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt128@) +M:System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.UInt128@) +M:System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) +M:System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt128@) +M:System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.UInt128@) +M:System.UInt128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) +M:System.UInt128.TryParse(System.String,System.IFormatProvider,System.UInt128@) +M:System.UInt128.TryParse(System.String,System.UInt128@) +M:System.UInt16.Clamp(System.UInt16,System.UInt16,System.UInt16) +M:System.UInt16.CompareTo(System.Object) +M:System.UInt16.CompareTo(System.UInt16) +M:System.UInt16.CreateChecked``1(``0) +M:System.UInt16.CreateSaturating``1(``0) +M:System.UInt16.CreateTruncating``1(``0) +M:System.UInt16.DivRem(System.UInt16,System.UInt16) +M:System.UInt16.Equals(System.Object) +M:System.UInt16.Equals(System.UInt16) +M:System.UInt16.GetHashCode +M:System.UInt16.GetTypeCode +M:System.UInt16.IsEvenInteger(System.UInt16) +M:System.UInt16.IsOddInteger(System.UInt16) +M:System.UInt16.IsPow2(System.UInt16) +M:System.UInt16.LeadingZeroCount(System.UInt16) +M:System.UInt16.Log2(System.UInt16) +M:System.UInt16.Max(System.UInt16,System.UInt16) +M:System.UInt16.Min(System.UInt16,System.UInt16) +M:System.UInt16.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt16.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.UInt16.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt16.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt16.Parse(System.String) +M:System.UInt16.Parse(System.String,System.Globalization.NumberStyles) +M:System.UInt16.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt16.Parse(System.String,System.IFormatProvider) +M:System.UInt16.PopCount(System.UInt16) +M:System.UInt16.RotateLeft(System.UInt16,System.Int32) +M:System.UInt16.RotateRight(System.UInt16,System.Int32) +M:System.UInt16.Sign(System.UInt16) +M:System.UInt16.ToString +M:System.UInt16.ToString(System.IFormatProvider) +M:System.UInt16.ToString(System.String) +M:System.UInt16.ToString(System.String,System.IFormatProvider) +M:System.UInt16.TrailingZeroCount(System.UInt16) +M:System.UInt16.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt16.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) +M:System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt16@) +M:System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.UInt16@) +M:System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) +M:System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt16@) +M:System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.UInt16@) +M:System.UInt16.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) +M:System.UInt16.TryParse(System.String,System.IFormatProvider,System.UInt16@) +M:System.UInt16.TryParse(System.String,System.UInt16@) +M:System.UInt32.Clamp(System.UInt32,System.UInt32,System.UInt32) +M:System.UInt32.CompareTo(System.Object) +M:System.UInt32.CompareTo(System.UInt32) +M:System.UInt32.CreateChecked``1(``0) +M:System.UInt32.CreateSaturating``1(``0) +M:System.UInt32.CreateTruncating``1(``0) +M:System.UInt32.DivRem(System.UInt32,System.UInt32) +M:System.UInt32.Equals(System.Object) +M:System.UInt32.Equals(System.UInt32) +M:System.UInt32.GetHashCode +M:System.UInt32.GetTypeCode +M:System.UInt32.IsEvenInteger(System.UInt32) +M:System.UInt32.IsOddInteger(System.UInt32) +M:System.UInt32.IsPow2(System.UInt32) +M:System.UInt32.LeadingZeroCount(System.UInt32) +M:System.UInt32.Log2(System.UInt32) +M:System.UInt32.Max(System.UInt32,System.UInt32) +M:System.UInt32.Min(System.UInt32,System.UInt32) +M:System.UInt32.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt32.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.UInt32.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt32.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt32.Parse(System.String) +M:System.UInt32.Parse(System.String,System.Globalization.NumberStyles) +M:System.UInt32.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt32.Parse(System.String,System.IFormatProvider) +M:System.UInt32.PopCount(System.UInt32) +M:System.UInt32.RotateLeft(System.UInt32,System.Int32) +M:System.UInt32.RotateRight(System.UInt32,System.Int32) +M:System.UInt32.Sign(System.UInt32) +M:System.UInt32.ToString +M:System.UInt32.ToString(System.IFormatProvider) +M:System.UInt32.ToString(System.String) +M:System.UInt32.ToString(System.String,System.IFormatProvider) +M:System.UInt32.TrailingZeroCount(System.UInt32) +M:System.UInt32.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt32.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) +M:System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt32@) +M:System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.UInt32@) +M:System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) +M:System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt32@) +M:System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.UInt32@) +M:System.UInt32.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) +M:System.UInt32.TryParse(System.String,System.IFormatProvider,System.UInt32@) +M:System.UInt32.TryParse(System.String,System.UInt32@) +M:System.UInt64.Clamp(System.UInt64,System.UInt64,System.UInt64) +M:System.UInt64.CompareTo(System.Object) +M:System.UInt64.CompareTo(System.UInt64) +M:System.UInt64.CreateChecked``1(``0) +M:System.UInt64.CreateSaturating``1(``0) +M:System.UInt64.CreateTruncating``1(``0) +M:System.UInt64.DivRem(System.UInt64,System.UInt64) +M:System.UInt64.Equals(System.Object) +M:System.UInt64.Equals(System.UInt64) +M:System.UInt64.GetHashCode +M:System.UInt64.GetTypeCode +M:System.UInt64.IsEvenInteger(System.UInt64) +M:System.UInt64.IsOddInteger(System.UInt64) +M:System.UInt64.IsPow2(System.UInt64) +M:System.UInt64.LeadingZeroCount(System.UInt64) +M:System.UInt64.Log2(System.UInt64) +M:System.UInt64.Max(System.UInt64,System.UInt64) +M:System.UInt64.Min(System.UInt64,System.UInt64) +M:System.UInt64.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt64.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.UInt64.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt64.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt64.Parse(System.String) +M:System.UInt64.Parse(System.String,System.Globalization.NumberStyles) +M:System.UInt64.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UInt64.Parse(System.String,System.IFormatProvider) +M:System.UInt64.PopCount(System.UInt64) +M:System.UInt64.RotateLeft(System.UInt64,System.Int32) +M:System.UInt64.RotateRight(System.UInt64,System.Int32) +M:System.UInt64.Sign(System.UInt64) +M:System.UInt64.ToString +M:System.UInt64.ToString(System.IFormatProvider) +M:System.UInt64.ToString(System.String) +M:System.UInt64.ToString(System.String,System.IFormatProvider) +M:System.UInt64.TrailingZeroCount(System.UInt64) +M:System.UInt64.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt64.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) +M:System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt64@) +M:System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.UInt64@) +M:System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) +M:System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt64@) +M:System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.UInt64@) +M:System.UInt64.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) +M:System.UInt64.TryParse(System.String,System.IFormatProvider,System.UInt64@) +M:System.UInt64.TryParse(System.String,System.UInt64@) +M:System.UIntPtr.#ctor(System.UInt32) +M:System.UIntPtr.#ctor(System.UInt64) +M:System.UIntPtr.#ctor(System.Void*) +M:System.UIntPtr.Add(System.UIntPtr,System.Int32) +M:System.UIntPtr.Clamp(System.UIntPtr,System.UIntPtr,System.UIntPtr) +M:System.UIntPtr.CompareTo(System.Object) +M:System.UIntPtr.CompareTo(System.UIntPtr) +M:System.UIntPtr.CreateChecked``1(``0) +M:System.UIntPtr.CreateSaturating``1(``0) +M:System.UIntPtr.CreateTruncating``1(``0) +M:System.UIntPtr.DivRem(System.UIntPtr,System.UIntPtr) +M:System.UIntPtr.Equals(System.Object) +M:System.UIntPtr.Equals(System.UIntPtr) +M:System.UIntPtr.get_MaxValue +M:System.UIntPtr.get_MinValue +M:System.UIntPtr.get_Size +M:System.UIntPtr.GetHashCode +M:System.UIntPtr.IsEvenInteger(System.UIntPtr) +M:System.UIntPtr.IsOddInteger(System.UIntPtr) +M:System.UIntPtr.IsPow2(System.UIntPtr) +M:System.UIntPtr.LeadingZeroCount(System.UIntPtr) +M:System.UIntPtr.Log2(System.UIntPtr) +M:System.UIntPtr.Max(System.UIntPtr,System.UIntPtr) +M:System.UIntPtr.Min(System.UIntPtr,System.UIntPtr) +M:System.UIntPtr.op_Addition(System.UIntPtr,System.Int32) +M:System.UIntPtr.op_Equality(System.UIntPtr,System.UIntPtr) +M:System.UIntPtr.op_Explicit(System.UInt32)~System.UIntPtr +M:System.UIntPtr.op_Explicit(System.UInt64)~System.UIntPtr +M:System.UIntPtr.op_Explicit(System.UIntPtr)~System.UInt32 +M:System.UIntPtr.op_Explicit(System.UIntPtr)~System.UInt64 +M:System.UIntPtr.op_Explicit(System.UIntPtr)~System.Void* +M:System.UIntPtr.op_Explicit(System.Void*)~System.UIntPtr +M:System.UIntPtr.op_Inequality(System.UIntPtr,System.UIntPtr) +M:System.UIntPtr.op_Subtraction(System.UIntPtr,System.Int32) +M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) +M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UIntPtr.Parse(System.String) +M:System.UIntPtr.Parse(System.String,System.Globalization.NumberStyles) +M:System.UIntPtr.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) +M:System.UIntPtr.Parse(System.String,System.IFormatProvider) +M:System.UIntPtr.PopCount(System.UIntPtr) +M:System.UIntPtr.RotateLeft(System.UIntPtr,System.Int32) +M:System.UIntPtr.RotateRight(System.UIntPtr,System.Int32) +M:System.UIntPtr.Sign(System.UIntPtr) +M:System.UIntPtr.Subtract(System.UIntPtr,System.Int32) +M:System.UIntPtr.ToPointer +M:System.UIntPtr.ToString +M:System.UIntPtr.ToString(System.IFormatProvider) +M:System.UIntPtr.ToString(System.String) +M:System.UIntPtr.ToString(System.String,System.IFormatProvider) +M:System.UIntPtr.ToUInt32 +M:System.UIntPtr.ToUInt64 +M:System.UIntPtr.TrailingZeroCount(System.UIntPtr) +M:System.UIntPtr.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UIntPtr.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) +M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) +M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UIntPtr@) +M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.UIntPtr@) +M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) +M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UIntPtr@) +M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.UIntPtr@) +M:System.UIntPtr.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) +M:System.UIntPtr.TryParse(System.String,System.IFormatProvider,System.UIntPtr@) +M:System.UIntPtr.TryParse(System.String,System.UIntPtr@) +M:System.UnauthorizedAccessException.#ctor +M:System.UnauthorizedAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.UnauthorizedAccessException.#ctor(System.String) +M:System.UnauthorizedAccessException.#ctor(System.String,System.Exception) +M:System.UnhandledExceptionEventArgs.#ctor(System.Object,System.Boolean) +M:System.UnhandledExceptionEventArgs.get_ExceptionObject +M:System.UnhandledExceptionEventArgs.get_IsTerminating +M:System.UnhandledExceptionEventHandler.#ctor(System.Object,System.IntPtr) +M:System.UnhandledExceptionEventHandler.BeginInvoke(System.Object,System.UnhandledExceptionEventArgs,System.AsyncCallback,System.Object) +M:System.UnhandledExceptionEventHandler.EndInvoke(System.IAsyncResult) +M:System.UnhandledExceptionEventHandler.Invoke(System.Object,System.UnhandledExceptionEventArgs) +M:System.Uri.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Uri.#ctor(System.String) +M:System.Uri.#ctor(System.String,System.Boolean) +M:System.Uri.#ctor(System.String,System.UriCreationOptions@) +M:System.Uri.#ctor(System.String,System.UriKind) +M:System.Uri.#ctor(System.Uri,System.String) +M:System.Uri.#ctor(System.Uri,System.String,System.Boolean) +M:System.Uri.#ctor(System.Uri,System.Uri) +M:System.Uri.Canonicalize +M:System.Uri.CheckHostName(System.String) +M:System.Uri.CheckSchemeName(System.String) +M:System.Uri.CheckSecurity +M:System.Uri.Compare(System.Uri,System.Uri,System.UriComponents,System.UriFormat,System.StringComparison) +M:System.Uri.Equals(System.Object) +M:System.Uri.Escape +M:System.Uri.EscapeDataString(System.String) +M:System.Uri.EscapeString(System.String) +M:System.Uri.EscapeUriString(System.String) +M:System.Uri.FromHex(System.Char) +M:System.Uri.get_AbsolutePath +M:System.Uri.get_AbsoluteUri +M:System.Uri.get_Authority +M:System.Uri.get_DnsSafeHost +M:System.Uri.get_Fragment +M:System.Uri.get_Host +M:System.Uri.get_HostNameType +M:System.Uri.get_IdnHost +M:System.Uri.get_IsAbsoluteUri +M:System.Uri.get_IsDefaultPort +M:System.Uri.get_IsFile +M:System.Uri.get_IsLoopback +M:System.Uri.get_IsUnc +M:System.Uri.get_LocalPath +M:System.Uri.get_OriginalString +M:System.Uri.get_PathAndQuery +M:System.Uri.get_Port +M:System.Uri.get_Query +M:System.Uri.get_Scheme +M:System.Uri.get_Segments +M:System.Uri.get_UserEscaped +M:System.Uri.get_UserInfo +M:System.Uri.GetComponents(System.UriComponents,System.UriFormat) +M:System.Uri.GetHashCode +M:System.Uri.GetLeftPart(System.UriPartial) +M:System.Uri.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.Uri.HexEscape(System.Char) +M:System.Uri.HexUnescape(System.String,System.Int32@) +M:System.Uri.IsBadFileSystemCharacter(System.Char) +M:System.Uri.IsBaseOf(System.Uri) +M:System.Uri.IsExcludedCharacter(System.Char) +M:System.Uri.IsHexDigit(System.Char) +M:System.Uri.IsHexEncoding(System.String,System.Int32) +M:System.Uri.IsReservedCharacter(System.Char) +M:System.Uri.IsWellFormedOriginalString +M:System.Uri.IsWellFormedUriString(System.String,System.UriKind) +M:System.Uri.MakeRelative(System.Uri) +M:System.Uri.MakeRelativeUri(System.Uri) +M:System.Uri.op_Equality(System.Uri,System.Uri) +M:System.Uri.op_Inequality(System.Uri,System.Uri) +M:System.Uri.Parse +M:System.Uri.ToString +M:System.Uri.TryCreate(System.String,System.UriCreationOptions@,System.Uri@) +M:System.Uri.TryCreate(System.String,System.UriKind,System.Uri@) +M:System.Uri.TryCreate(System.Uri,System.String,System.Uri@) +M:System.Uri.TryCreate(System.Uri,System.Uri,System.Uri@) +M:System.Uri.TryFormat(System.Span{System.Char},System.Int32@) +M:System.Uri.Unescape(System.String) +M:System.Uri.UnescapeDataString(System.String) +M:System.UriBuilder.#ctor +M:System.UriBuilder.#ctor(System.String) +M:System.UriBuilder.#ctor(System.String,System.String) +M:System.UriBuilder.#ctor(System.String,System.String,System.Int32) +M:System.UriBuilder.#ctor(System.String,System.String,System.Int32,System.String) +M:System.UriBuilder.#ctor(System.String,System.String,System.Int32,System.String,System.String) +M:System.UriBuilder.#ctor(System.Uri) +M:System.UriBuilder.Equals(System.Object) +M:System.UriBuilder.get_Fragment +M:System.UriBuilder.get_Host +M:System.UriBuilder.get_Password +M:System.UriBuilder.get_Path +M:System.UriBuilder.get_Port +M:System.UriBuilder.get_Query +M:System.UriBuilder.get_Scheme +M:System.UriBuilder.get_Uri +M:System.UriBuilder.get_UserName +M:System.UriBuilder.GetHashCode +M:System.UriBuilder.set_Fragment(System.String) +M:System.UriBuilder.set_Host(System.String) +M:System.UriBuilder.set_Password(System.String) +M:System.UriBuilder.set_Path(System.String) +M:System.UriBuilder.set_Port(System.Int32) +M:System.UriBuilder.set_Query(System.String) +M:System.UriBuilder.set_Scheme(System.String) +M:System.UriBuilder.set_UserName(System.String) +M:System.UriBuilder.ToString +M:System.UriCreationOptions.get_DangerousDisablePathAndQueryCanonicalization +M:System.UriCreationOptions.set_DangerousDisablePathAndQueryCanonicalization(System.Boolean) +M:System.UriFormatException.#ctor +M:System.UriFormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.UriFormatException.#ctor(System.String) +M:System.UriFormatException.#ctor(System.String,System.Exception) +M:System.UriParser.#ctor +M:System.UriParser.GetComponents(System.Uri,System.UriComponents,System.UriFormat) +M:System.UriParser.InitializeAndValidate(System.Uri,System.UriFormatException@) +M:System.UriParser.IsBaseOf(System.Uri,System.Uri) +M:System.UriParser.IsKnownScheme(System.String) +M:System.UriParser.IsWellFormedOriginalString(System.Uri) +M:System.UriParser.OnNewUri +M:System.UriParser.OnRegister(System.String,System.Int32) +M:System.UriParser.Register(System.UriParser,System.String,System.Int32) +M:System.UriParser.Resolve(System.Uri,System.Uri,System.UriFormatException@) +M:System.ValueTuple.CompareTo(System.ValueTuple) +M:System.ValueTuple.Create +M:System.ValueTuple.Create``1(``0) +M:System.ValueTuple.Create``2(``0,``1) +M:System.ValueTuple.Create``3(``0,``1,``2) +M:System.ValueTuple.Create``4(``0,``1,``2,``3) +M:System.ValueTuple.Create``5(``0,``1,``2,``3,``4) +M:System.ValueTuple.Create``6(``0,``1,``2,``3,``4,``5) +M:System.ValueTuple.Create``7(``0,``1,``2,``3,``4,``5,``6) +M:System.ValueTuple.Create``8(``0,``1,``2,``3,``4,``5,``6,``7) +M:System.ValueTuple.Equals(System.Object) +M:System.ValueTuple.Equals(System.ValueTuple) +M:System.ValueTuple.GetHashCode +M:System.ValueTuple.ToString +M:System.ValueTuple`1.#ctor(`0) +M:System.ValueTuple`1.CompareTo(System.ValueTuple{`0}) +M:System.ValueTuple`1.Equals(System.Object) +M:System.ValueTuple`1.Equals(System.ValueTuple{`0}) +M:System.ValueTuple`1.GetHashCode +M:System.ValueTuple`1.ToString +M:System.ValueTuple`2.#ctor(`0,`1) +M:System.ValueTuple`2.CompareTo(System.ValueTuple{`0,`1}) +M:System.ValueTuple`2.Equals(System.Object) +M:System.ValueTuple`2.Equals(System.ValueTuple{`0,`1}) +M:System.ValueTuple`2.GetHashCode +M:System.ValueTuple`2.ToString +M:System.ValueTuple`3.#ctor(`0,`1,`2) +M:System.ValueTuple`3.CompareTo(System.ValueTuple{`0,`1,`2}) +M:System.ValueTuple`3.Equals(System.Object) +M:System.ValueTuple`3.Equals(System.ValueTuple{`0,`1,`2}) +M:System.ValueTuple`3.GetHashCode +M:System.ValueTuple`3.ToString +M:System.ValueTuple`4.#ctor(`0,`1,`2,`3) +M:System.ValueTuple`4.CompareTo(System.ValueTuple{`0,`1,`2,`3}) +M:System.ValueTuple`4.Equals(System.Object) +M:System.ValueTuple`4.Equals(System.ValueTuple{`0,`1,`2,`3}) +M:System.ValueTuple`4.GetHashCode +M:System.ValueTuple`4.ToString +M:System.ValueTuple`5.#ctor(`0,`1,`2,`3,`4) +M:System.ValueTuple`5.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4}) +M:System.ValueTuple`5.Equals(System.Object) +M:System.ValueTuple`5.Equals(System.ValueTuple{`0,`1,`2,`3,`4}) +M:System.ValueTuple`5.GetHashCode +M:System.ValueTuple`5.ToString +M:System.ValueTuple`6.#ctor(`0,`1,`2,`3,`4,`5) +M:System.ValueTuple`6.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5}) +M:System.ValueTuple`6.Equals(System.Object) +M:System.ValueTuple`6.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5}) +M:System.ValueTuple`6.GetHashCode +M:System.ValueTuple`6.ToString +M:System.ValueTuple`7.#ctor(`0,`1,`2,`3,`4,`5,`6) +M:System.ValueTuple`7.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6}) +M:System.ValueTuple`7.Equals(System.Object) +M:System.ValueTuple`7.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6}) +M:System.ValueTuple`7.GetHashCode +M:System.ValueTuple`7.ToString +M:System.ValueTuple`8.#ctor(`0,`1,`2,`3,`4,`5,`6,`7) +M:System.ValueTuple`8.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6,`7}) +M:System.ValueTuple`8.Equals(System.Object) +M:System.ValueTuple`8.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6,`7}) +M:System.ValueTuple`8.GetHashCode +M:System.ValueTuple`8.ToString +M:System.ValueType.#ctor +M:System.ValueType.Equals(System.Object) +M:System.ValueType.GetHashCode +M:System.ValueType.ToString +M:System.Version.#ctor +M:System.Version.#ctor(System.Int32,System.Int32) +M:System.Version.#ctor(System.Int32,System.Int32,System.Int32) +M:System.Version.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) +M:System.Version.#ctor(System.String) +M:System.Version.Clone +M:System.Version.CompareTo(System.Object) +M:System.Version.CompareTo(System.Version) +M:System.Version.Equals(System.Object) +M:System.Version.Equals(System.Version) +M:System.Version.get_Build +M:System.Version.get_Major +M:System.Version.get_MajorRevision +M:System.Version.get_Minor +M:System.Version.get_MinorRevision +M:System.Version.get_Revision +M:System.Version.GetHashCode +M:System.Version.op_Equality(System.Version,System.Version) +M:System.Version.op_GreaterThan(System.Version,System.Version) +M:System.Version.op_GreaterThanOrEqual(System.Version,System.Version) +M:System.Version.op_Inequality(System.Version,System.Version) +M:System.Version.op_LessThan(System.Version,System.Version) +M:System.Version.op_LessThanOrEqual(System.Version,System.Version) +M:System.Version.Parse(System.ReadOnlySpan{System.Char}) +M:System.Version.Parse(System.String) +M:System.Version.ToString +M:System.Version.ToString(System.Int32) +M:System.Version.TryFormat(System.Span{System.Byte},System.Int32,System.Int32@) +M:System.Version.TryFormat(System.Span{System.Byte},System.Int32@) +M:System.Version.TryFormat(System.Span{System.Char},System.Int32,System.Int32@) +M:System.Version.TryFormat(System.Span{System.Char},System.Int32@) +M:System.Version.TryParse(System.ReadOnlySpan{System.Char},System.Version@) +M:System.Version.TryParse(System.String,System.Version@) +M:System.WeakReference.#ctor(System.Object) +M:System.WeakReference.#ctor(System.Object,System.Boolean) +M:System.WeakReference.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.WeakReference.Finalize +M:System.WeakReference.get_IsAlive +M:System.WeakReference.get_Target +M:System.WeakReference.get_TrackResurrection +M:System.WeakReference.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.WeakReference.set_Target(System.Object) +M:System.WeakReference`1.#ctor(`0) +M:System.WeakReference`1.#ctor(`0,System.Boolean) +M:System.WeakReference`1.Finalize +M:System.WeakReference`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) +M:System.WeakReference`1.SetTarget(`0) +M:System.WeakReference`1.TryGetTarget(`0@) +T:System.AccessViolationException +T:System.Action +T:System.Action`1 +T:System.Action`10 +T:System.Action`11 +T:System.Action`12 +T:System.Action`13 +T:System.Action`14 +T:System.Action`15 +T:System.Action`16 +T:System.Action`2 +T:System.Action`3 +T:System.Action`4 +T:System.Action`5 +T:System.Action`6 +T:System.Action`7 +T:System.Action`8 +T:System.Action`9 +T:System.AggregateException +T:System.ApplicationException +T:System.ApplicationId +T:System.ArgIterator +T:System.ArgumentException +T:System.ArgumentNullException +T:System.ArgumentOutOfRangeException +T:System.ArithmeticException +T:System.Array +T:System.ArraySegment`1 +T:System.ArraySegment`1.Enumerator +T:System.ArrayTypeMismatchException +T:System.AsyncCallback +T:System.Attribute +T:System.AttributeTargets +T:System.AttributeUsageAttribute +T:System.BadImageFormatException +T:System.Base64FormattingOptions +T:System.BitConverter +T:System.Boolean +T:System.Buffer +T:System.Buffers.ArrayPool`1 +T:System.Buffers.IMemoryOwner`1 +T:System.Buffers.IPinnable +T:System.Buffers.MemoryHandle +T:System.Buffers.MemoryManager`1 +T:System.Buffers.OperationStatus +T:System.Buffers.ReadOnlySpanAction`2 +T:System.Buffers.SearchValues +T:System.Buffers.SearchValues`1 +T:System.Buffers.SpanAction`2 +T:System.Buffers.Text.Base64 +T:System.Byte +T:System.CannotUnloadAppDomainException +T:System.Char +T:System.CharEnumerator +T:System.CLSCompliantAttribute +T:System.CodeDom.Compiler.GeneratedCodeAttribute +T:System.CodeDom.Compiler.IndentedTextWriter +T:System.Collections.ArrayList +T:System.Collections.Comparer +T:System.Collections.DictionaryEntry +T:System.Collections.Generic.IAsyncEnumerable`1 +T:System.Collections.Generic.IAsyncEnumerator`1 +T:System.Collections.Generic.ICollection`1 +T:System.Collections.Generic.IComparer`1 +T:System.Collections.Generic.IDictionary`2 +T:System.Collections.Generic.IEnumerable`1 +T:System.Collections.Generic.IEnumerator`1 +T:System.Collections.Generic.IEqualityComparer`1 +T:System.Collections.Generic.IList`1 +T:System.Collections.Generic.IReadOnlyCollection`1 +T:System.Collections.Generic.IReadOnlyDictionary`2 +T:System.Collections.Generic.IReadOnlyList`1 +T:System.Collections.Generic.IReadOnlySet`1 +T:System.Collections.Generic.ISet`1 +T:System.Collections.Generic.KeyNotFoundException +T:System.Collections.Generic.KeyValuePair +T:System.Collections.Generic.KeyValuePair`2 +T:System.Collections.Hashtable +T:System.Collections.ICollection +T:System.Collections.IComparer +T:System.Collections.IDictionary +T:System.Collections.IDictionaryEnumerator +T:System.Collections.IEnumerable +T:System.Collections.IEnumerator +T:System.Collections.IEqualityComparer +T:System.Collections.IHashCodeProvider +T:System.Collections.IList +T:System.Collections.IStructuralComparable +T:System.Collections.IStructuralEquatable +T:System.Collections.ObjectModel.Collection`1 +T:System.Collections.ObjectModel.ReadOnlyCollection`1 +T:System.Collections.ObjectModel.ReadOnlyDictionary`2 +T:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection +T:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection +T:System.Comparison`1 +T:System.ComponentModel.DefaultValueAttribute +T:System.ComponentModel.EditorBrowsableAttribute +T:System.ComponentModel.EditorBrowsableState +T:System.Configuration.Assemblies.AssemblyHashAlgorithm +T:System.Configuration.Assemblies.AssemblyVersionCompatibility +T:System.ContextBoundObject +T:System.ContextMarshalException +T:System.ContextStaticAttribute +T:System.Convert +T:System.Converter`2 +T:System.DateOnly +T:System.DateTime +T:System.DateTimeKind +T:System.DateTimeOffset +T:System.DayOfWeek +T:System.DBNull +T:System.Decimal +T:System.Delegate +T:System.Diagnostics.CodeAnalysis.AllowNullAttribute +T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute +T:System.Diagnostics.CodeAnalysis.DisallowNullAttribute +T:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute +T:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute +T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute +T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes +T:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute +T:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute +T:System.Diagnostics.CodeAnalysis.ExperimentalAttribute +T:System.Diagnostics.CodeAnalysis.MaybeNullAttribute +T:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute +T:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute +T:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute +T:System.Diagnostics.CodeAnalysis.NotNullAttribute +T:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute +T:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute +T:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute +T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute +T:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute +T:System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute +T:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute +T:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute +T:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute +T:System.Diagnostics.CodeAnalysis.UnscopedRefAttribute +T:System.Diagnostics.ConditionalAttribute +T:System.Diagnostics.Debug +T:System.Diagnostics.Debug.AssertInterpolatedStringHandler +T:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler +T:System.Diagnostics.DebuggableAttribute +T:System.Diagnostics.DebuggableAttribute.DebuggingModes +T:System.Diagnostics.DebuggerBrowsableAttribute +T:System.Diagnostics.DebuggerBrowsableState +T:System.Diagnostics.DebuggerDisplayAttribute +T:System.Diagnostics.DebuggerHiddenAttribute +T:System.Diagnostics.DebuggerNonUserCodeAttribute +T:System.Diagnostics.DebuggerStepperBoundaryAttribute +T:System.Diagnostics.DebuggerStepThroughAttribute +T:System.Diagnostics.DebuggerTypeProxyAttribute +T:System.Diagnostics.DebuggerVisualizerAttribute +T:System.Diagnostics.StackTraceHiddenAttribute +T:System.Diagnostics.Stopwatch +T:System.Diagnostics.UnreachableException +T:System.DivideByZeroException +T:System.Double +T:System.DuplicateWaitObjectException +T:System.EntryPointNotFoundException +T:System.Enum +T:System.Environment +T:System.EventArgs +T:System.EventHandler +T:System.EventHandler`1 +T:System.Exception +T:System.ExecutionEngineException +T:System.FieldAccessException +T:System.FileStyleUriParser +T:System.FlagsAttribute +T:System.FormatException +T:System.FormattableString +T:System.FtpStyleUriParser +T:System.Func`1 +T:System.Func`10 +T:System.Func`11 +T:System.Func`12 +T:System.Func`13 +T:System.Func`14 +T:System.Func`15 +T:System.Func`16 +T:System.Func`17 +T:System.Func`2 +T:System.Func`3 +T:System.Func`4 +T:System.Func`5 +T:System.Func`6 +T:System.Func`7 +T:System.Func`8 +T:System.Func`9 +T:System.GenericUriParser +T:System.GenericUriParserOptions +T:System.Globalization.Calendar +T:System.Globalization.CalendarAlgorithmType +T:System.Globalization.CalendarWeekRule +T:System.Globalization.CharUnicodeInfo +T:System.Globalization.ChineseLunisolarCalendar +T:System.Globalization.CompareInfo +T:System.Globalization.CompareOptions +T:System.Globalization.CultureInfo +T:System.Globalization.CultureNotFoundException +T:System.Globalization.CultureTypes +T:System.Globalization.DateTimeFormatInfo +T:System.Globalization.DateTimeStyles +T:System.Globalization.DaylightTime +T:System.Globalization.DigitShapes +T:System.Globalization.EastAsianLunisolarCalendar +T:System.Globalization.GlobalizationExtensions +T:System.Globalization.GregorianCalendar +T:System.Globalization.GregorianCalendarTypes +T:System.Globalization.HebrewCalendar +T:System.Globalization.HijriCalendar +T:System.Globalization.IdnMapping +T:System.Globalization.ISOWeek +T:System.Globalization.JapaneseCalendar +T:System.Globalization.JapaneseLunisolarCalendar +T:System.Globalization.JulianCalendar +T:System.Globalization.KoreanCalendar +T:System.Globalization.KoreanLunisolarCalendar +T:System.Globalization.NumberFormatInfo +T:System.Globalization.NumberStyles +T:System.Globalization.PersianCalendar +T:System.Globalization.RegionInfo +T:System.Globalization.SortKey +T:System.Globalization.SortVersion +T:System.Globalization.StringInfo +T:System.Globalization.TaiwanCalendar +T:System.Globalization.TaiwanLunisolarCalendar +T:System.Globalization.TextElementEnumerator +T:System.Globalization.TextInfo +T:System.Globalization.ThaiBuddhistCalendar +T:System.Globalization.TimeSpanStyles +T:System.Globalization.UmAlQuraCalendar +T:System.Globalization.UnicodeCategory +T:System.GopherStyleUriParser +T:System.Guid +T:System.Half +T:System.HashCode +T:System.HttpStyleUriParser +T:System.IAsyncDisposable +T:System.IAsyncResult +T:System.ICloneable +T:System.IComparable +T:System.IComparable`1 +T:System.IConvertible +T:System.ICustomFormatter +T:System.IDisposable +T:System.IEquatable`1 +T:System.IFormatProvider +T:System.IFormattable +T:System.Index +T:System.IndexOutOfRangeException +T:System.InsufficientExecutionStackException +T:System.InsufficientMemoryException +T:System.Int128 +T:System.Int16 +T:System.Int32 +T:System.Int64 +T:System.IntPtr +T:System.InvalidCastException +T:System.InvalidOperationException +T:System.InvalidProgramException +T:System.InvalidTimeZoneException +T:System.IObservable`1 +T:System.IObserver`1 +T:System.IParsable`1 +T:System.IProgress`1 +T:System.ISpanFormattable +T:System.ISpanParsable`1 +T:System.IUtf8SpanFormattable +T:System.IUtf8SpanParsable`1 +T:System.Lazy`1 +T:System.Lazy`2 +T:System.LdapStyleUriParser +T:System.Math +T:System.MathF +T:System.MemberAccessException +T:System.Memory`1 +T:System.MethodAccessException +T:System.MidpointRounding +T:System.MissingFieldException +T:System.MissingMemberException +T:System.MissingMethodException +T:System.ModuleHandle +T:System.MulticastDelegate +T:System.MulticastNotSupportedException +T:System.NetPipeStyleUriParser +T:System.NetTcpStyleUriParser +T:System.NewsStyleUriParser +T:System.NonSerializedAttribute +T:System.NotFiniteNumberException +T:System.NotImplementedException +T:System.NotSupportedException +T:System.Nullable +T:System.Nullable`1 +T:System.NullReferenceException +T:System.Numerics.BitOperations +T:System.Numerics.IAdditionOperators`3 +T:System.Numerics.IAdditiveIdentity`2 +T:System.Numerics.IBinaryFloatingPointIeee754`1 +T:System.Numerics.IBinaryInteger`1 +T:System.Numerics.IBinaryNumber`1 +T:System.Numerics.IBitwiseOperators`3 +T:System.Numerics.IComparisonOperators`3 +T:System.Numerics.IDecrementOperators`1 +T:System.Numerics.IDivisionOperators`3 +T:System.Numerics.IEqualityOperators`3 +T:System.Numerics.IExponentialFunctions`1 +T:System.Numerics.IFloatingPoint`1 +T:System.Numerics.IFloatingPointConstants`1 +T:System.Numerics.IFloatingPointIeee754`1 +T:System.Numerics.IHyperbolicFunctions`1 +T:System.Numerics.IIncrementOperators`1 +T:System.Numerics.ILogarithmicFunctions`1 +T:System.Numerics.IMinMaxValue`1 +T:System.Numerics.IModulusOperators`3 +T:System.Numerics.IMultiplicativeIdentity`2 +T:System.Numerics.IMultiplyOperators`3 +T:System.Numerics.INumber`1 +T:System.Numerics.INumberBase`1 +T:System.Numerics.IPowerFunctions`1 +T:System.Numerics.IRootFunctions`1 +T:System.Numerics.IShiftOperators`3 +T:System.Numerics.ISignedNumber`1 +T:System.Numerics.ISubtractionOperators`3 +T:System.Numerics.ITrigonometricFunctions`1 +T:System.Numerics.IUnaryNegationOperators`2 +T:System.Numerics.IUnaryPlusOperators`2 +T:System.Numerics.IUnsignedNumber`1 +T:System.Numerics.TotalOrderIeee754Comparer`1 +T:System.Object +T:System.ObjectDisposedException +T:System.ObsoleteAttribute +T:System.OperatingSystem +T:System.OperationCanceledException +T:System.OutOfMemoryException +T:System.OverflowException +T:System.ParamArrayAttribute +T:System.PlatformID +T:System.PlatformNotSupportedException +T:System.Predicate`1 +T:System.Progress`1 +T:System.Random +T:System.Range +T:System.RankException +T:System.ReadOnlyMemory`1 +T:System.ReadOnlySpan`1 +T:System.ReadOnlySpan`1.Enumerator +T:System.ResolveEventArgs +T:System.ResolveEventHandler +T:System.Runtime.CompilerServices.AccessedThroughPropertyAttribute +T:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder +T:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute +T:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute +T:System.Runtime.CompilerServices.AsyncStateMachineAttribute +T:System.Runtime.CompilerServices.AsyncTaskMethodBuilder +T:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 +T:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder +T:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 +T:System.Runtime.CompilerServices.AsyncVoidMethodBuilder +T:System.Runtime.CompilerServices.CallConvCdecl +T:System.Runtime.CompilerServices.CallConvFastcall +T:System.Runtime.CompilerServices.CallConvMemberFunction +T:System.Runtime.CompilerServices.CallConvStdcall +T:System.Runtime.CompilerServices.CallConvSuppressGCTransition +T:System.Runtime.CompilerServices.CallConvThiscall +T:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute +T:System.Runtime.CompilerServices.CallerFilePathAttribute +T:System.Runtime.CompilerServices.CallerLineNumberAttribute +T:System.Runtime.CompilerServices.CallerMemberNameAttribute +T:System.Runtime.CompilerServices.CollectionBuilderAttribute +T:System.Runtime.CompilerServices.CompilationRelaxations +T:System.Runtime.CompilerServices.CompilationRelaxationsAttribute +T:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute +T:System.Runtime.CompilerServices.CompilerGeneratedAttribute +T:System.Runtime.CompilerServices.CompilerGlobalScopeAttribute +T:System.Runtime.CompilerServices.ConditionalWeakTable`2 +T:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback +T:System.Runtime.CompilerServices.ConfiguredAsyncDisposable +T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1 +T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator +T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable +T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter +T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1 +T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter +T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable +T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter +T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1 +T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter +T:System.Runtime.CompilerServices.CustomConstantAttribute +T:System.Runtime.CompilerServices.DateTimeConstantAttribute +T:System.Runtime.CompilerServices.DecimalConstantAttribute +T:System.Runtime.CompilerServices.DefaultDependencyAttribute +T:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler +T:System.Runtime.CompilerServices.DependencyAttribute +T:System.Runtime.CompilerServices.DisablePrivateReflectionAttribute +T:System.Runtime.CompilerServices.DisableRuntimeMarshallingAttribute +T:System.Runtime.CompilerServices.DiscardableAttribute +T:System.Runtime.CompilerServices.EnumeratorCancellationAttribute +T:System.Runtime.CompilerServices.ExtensionAttribute +T:System.Runtime.CompilerServices.FixedAddressValueTypeAttribute +T:System.Runtime.CompilerServices.FixedBufferAttribute +T:System.Runtime.CompilerServices.FormattableStringFactory +T:System.Runtime.CompilerServices.IAsyncStateMachine +T:System.Runtime.CompilerServices.ICriticalNotifyCompletion +T:System.Runtime.CompilerServices.IndexerNameAttribute +T:System.Runtime.CompilerServices.InlineArrayAttribute +T:System.Runtime.CompilerServices.INotifyCompletion +T:System.Runtime.CompilerServices.InternalsVisibleToAttribute +T:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute +T:System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute +T:System.Runtime.CompilerServices.IsByRefLikeAttribute +T:System.Runtime.CompilerServices.IsConst +T:System.Runtime.CompilerServices.IsExternalInit +T:System.Runtime.CompilerServices.IsReadOnlyAttribute +T:System.Runtime.CompilerServices.IStrongBox +T:System.Runtime.CompilerServices.IsUnmanagedAttribute +T:System.Runtime.CompilerServices.IsVolatile +T:System.Runtime.CompilerServices.IteratorStateMachineAttribute +T:System.Runtime.CompilerServices.ITuple +T:System.Runtime.CompilerServices.LoadHint +T:System.Runtime.CompilerServices.MethodCodeType +T:System.Runtime.CompilerServices.MethodImplAttribute +T:System.Runtime.CompilerServices.MethodImplOptions +T:System.Runtime.CompilerServices.ModuleInitializerAttribute +T:System.Runtime.CompilerServices.NullableAttribute +T:System.Runtime.CompilerServices.NullableContextAttribute +T:System.Runtime.CompilerServices.NullablePublicOnlyAttribute +T:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder +T:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1 +T:System.Runtime.CompilerServices.PreserveBaseOverridesAttribute +T:System.Runtime.CompilerServices.ReferenceAssemblyAttribute +T:System.Runtime.CompilerServices.RefSafetyRulesAttribute +T:System.Runtime.CompilerServices.RequiredMemberAttribute +T:System.Runtime.CompilerServices.RequiresLocationAttribute +T:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute +T:System.Runtime.CompilerServices.RuntimeFeature +T:System.Runtime.CompilerServices.RuntimeHelpers +T:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode +T:System.Runtime.CompilerServices.RuntimeHelpers.TryCode +T:System.Runtime.CompilerServices.RuntimeWrappedException +T:System.Runtime.CompilerServices.ScopedRefAttribute +T:System.Runtime.CompilerServices.SkipLocalsInitAttribute +T:System.Runtime.CompilerServices.SpecialNameAttribute +T:System.Runtime.CompilerServices.StateMachineAttribute +T:System.Runtime.CompilerServices.StringFreezingAttribute +T:System.Runtime.CompilerServices.StrongBox`1 +T:System.Runtime.CompilerServices.SuppressIldasmAttribute +T:System.Runtime.CompilerServices.SwitchExpressionException +T:System.Runtime.CompilerServices.TaskAwaiter +T:System.Runtime.CompilerServices.TaskAwaiter`1 +T:System.Runtime.CompilerServices.TupleElementNamesAttribute +T:System.Runtime.CompilerServices.TypeForwardedFromAttribute +T:System.Runtime.CompilerServices.TypeForwardedToAttribute +T:System.Runtime.CompilerServices.Unsafe +T:System.Runtime.CompilerServices.UnsafeAccessorAttribute +T:System.Runtime.CompilerServices.UnsafeAccessorKind +T:System.Runtime.CompilerServices.UnsafeValueTypeAttribute +T:System.Runtime.CompilerServices.ValueTaskAwaiter +T:System.Runtime.CompilerServices.ValueTaskAwaiter`1 +T:System.Runtime.CompilerServices.YieldAwaitable +T:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter +T:System.RuntimeArgumentHandle +T:System.RuntimeFieldHandle +T:System.RuntimeMethodHandle +T:System.RuntimeTypeHandle +T:System.SByte +T:System.SerializableAttribute +T:System.Single +T:System.Span`1 +T:System.Span`1.Enumerator +T:System.StackOverflowException +T:System.String +T:System.StringComparer +T:System.StringComparison +T:System.StringNormalizationExtensions +T:System.StringSplitOptions +T:System.SystemException +T:System.Text.Ascii +T:System.Text.CompositeFormat +T:System.Text.Decoder +T:System.Text.DecoderExceptionFallback +T:System.Text.DecoderExceptionFallbackBuffer +T:System.Text.DecoderFallback +T:System.Text.DecoderFallbackBuffer +T:System.Text.DecoderFallbackException +T:System.Text.DecoderReplacementFallback +T:System.Text.DecoderReplacementFallbackBuffer +T:System.Text.Encoder +T:System.Text.EncoderExceptionFallback +T:System.Text.EncoderExceptionFallbackBuffer +T:System.Text.EncoderFallback +T:System.Text.EncoderFallbackBuffer +T:System.Text.EncoderFallbackException +T:System.Text.EncoderReplacementFallback +T:System.Text.EncoderReplacementFallbackBuffer +T:System.Text.Encoding +T:System.Text.EncodingInfo +T:System.Text.EncodingProvider +T:System.Text.NormalizationForm +T:System.Text.Rune +T:System.Text.StringBuilder +T:System.Text.StringBuilder.AppendInterpolatedStringHandler +T:System.Text.StringBuilder.ChunkEnumerator +T:System.Text.StringRuneEnumerator +T:System.Text.Unicode.Utf8 +T:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler +T:System.Threading.CancellationToken +T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair +T:System.Threading.Tasks.ConfigureAwaitOptions +T:System.Threading.Tasks.Sources.IValueTaskSource +T:System.Threading.Tasks.Sources.IValueTaskSource`1 +T:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1 +T:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags +T:System.Threading.Tasks.Sources.ValueTaskSourceStatus +T:System.Threading.Tasks.Task +T:System.Threading.Tasks.Task`1 +T:System.Threading.Tasks.TaskAsyncEnumerableExtensions +T:System.Threading.Tasks.TaskCanceledException +T:System.Threading.Tasks.TaskCompletionSource +T:System.Threading.Tasks.TaskCompletionSource`1 +T:System.Threading.Tasks.TaskContinuationOptions +T:System.Threading.Tasks.TaskCreationOptions +T:System.Threading.Tasks.TaskExtensions +T:System.Threading.Tasks.TaskSchedulerException +T:System.Threading.Tasks.TaskStatus +T:System.Threading.Tasks.TaskToAsyncResult +T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs +T:System.Threading.Tasks.ValueTask +T:System.Threading.Tasks.ValueTask`1 +T:System.TimeOnly +T:System.TimeoutException +T:System.TimeProvider +T:System.TimeSpan +T:System.TimeZone +T:System.TimeZoneInfo +T:System.TimeZoneInfo.AdjustmentRule +T:System.TimeZoneInfo.TransitionTime +T:System.TimeZoneNotFoundException +T:System.Tuple +T:System.Tuple`1 +T:System.Tuple`2 +T:System.Tuple`3 +T:System.Tuple`4 +T:System.Tuple`5 +T:System.Tuple`6 +T:System.Tuple`7 +T:System.Tuple`8 +T:System.TupleExtensions +T:System.Type +T:System.TypeAccessException +T:System.TypeCode +T:System.TypedReference +T:System.TypeInitializationException +T:System.TypeLoadException +T:System.TypeUnloadedException +T:System.UInt128 +T:System.UInt16 +T:System.UInt32 +T:System.UInt64 +T:System.UIntPtr +T:System.UnauthorizedAccessException +T:System.UnhandledExceptionEventArgs +T:System.UnhandledExceptionEventHandler +T:System.Uri +T:System.UriBuilder +T:System.UriComponents +T:System.UriCreationOptions +T:System.UriFormat +T:System.UriFormatException +T:System.UriHostNameType +T:System.UriKind +T:System.UriParser +T:System.UriPartial +T:System.ValueTuple +T:System.ValueTuple`1 +T:System.ValueTuple`2 +T:System.ValueTuple`3 +T:System.ValueTuple`4 +T:System.ValueTuple`5 +T:System.ValueTuple`6 +T:System.ValueTuple`7 +T:System.ValueTuple`8 +T:System.ValueType +T:System.Version +T:System.Void +T:System.WeakReference +T:System.WeakReference`1 \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj b/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj index 445516a39de98..b08e786e53a46 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj @@ -6,6 +6,7 @@ <_BuildTaskTfm Condition="'$(MSBuildRuntimeType)' != 'Core'">net472 <_BuildTaskTfm Condition="'$(MSBuildRuntimeType)' == 'Core'">$(NetRoslyn) <_BuildTaskAssemblyFile>$(ArtifactsBinDir)SemanticSearch.BuildTask\$(Configuration)\$(_BuildTaskTfm)\SemanticSearch.BuildTask.dll + <_ApisDir>$(MSBuildThisFileDirectory)Apis\ @@ -19,6 +20,7 @@ + + $(NetVSShared);net472 Microsoft.CodeAnalysis.CSharp.UnitTests true @@ -21,7 +22,7 @@ SemanticSearch_RefAssemblies - TargetFramework=$(NetRoslyn) + TargetFramework=$(NetVS) diff --git a/src/Features/Test/Microsoft.CodeAnalysis.Features.UnitTests.csproj b/src/Features/Test/Microsoft.CodeAnalysis.Features.UnitTests.csproj index 30b872be43867..77302d2df35ae 100644 --- a/src/Features/Test/Microsoft.CodeAnalysis.Features.UnitTests.csproj +++ b/src/Features/Test/Microsoft.CodeAnalysis.Features.UnitTests.csproj @@ -4,7 +4,8 @@ Library Microsoft.CodeAnalysis.UnitTests - $(NetRoslyn);net472 + + $(NetVSShared);net472 true diff --git a/src/Features/TestUtilities/Microsoft.CodeAnalysis.Features.Test.Utilities.csproj b/src/Features/TestUtilities/Microsoft.CodeAnalysis.Features.Test.Utilities.csproj index 4edb5fc441100..2aa8f604ab261 100644 --- a/src/Features/TestUtilities/Microsoft.CodeAnalysis.Features.Test.Utilities.csproj +++ b/src/Features/TestUtilities/Microsoft.CodeAnalysis.Features.Test.Utilities.csproj @@ -4,7 +4,7 @@ Library Microsoft.CodeAnalysis.Test.Utilities - $(NetRoslynAll);net472 + $(NetVS);net472 true false true diff --git a/src/Features/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Features.UnitTests.vbproj b/src/Features/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Features.UnitTests.vbproj index 63f99b49e73ee..0b3377fb79353 100644 --- a/src/Features/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Features.UnitTests.vbproj +++ b/src/Features/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Features.UnitTests.vbproj @@ -3,7 +3,8 @@ Library - $(NetRoslyn);net472 + + $(NetVSShared);net472 diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt index 048eb78842382..1977066cdea78 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.Immutable.txt @@ -4,21 +4,14 @@ System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collecti System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) System.Collections.Frozen.FrozenDictionary`2 -System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1 -System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.ContainsKey(`2) -System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.TryGetValue(`2,`1@) -System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.get_Dictionary -System.Collections.Frozen.FrozenDictionary`2.AlternateLookup`1.get_Item(`2) System.Collections.Frozen.FrozenDictionary`2.ContainsKey(`0) System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Span{System.Collections.Generic.KeyValuePair{`0,`1}}) System.Collections.Frozen.FrozenDictionary`2.Enumerator System.Collections.Frozen.FrozenDictionary`2.Enumerator.MoveNext System.Collections.Frozen.FrozenDictionary`2.Enumerator.get_Current -System.Collections.Frozen.FrozenDictionary`2.GetAlternateLookup``1 System.Collections.Frozen.FrozenDictionary`2.GetEnumerator System.Collections.Frozen.FrozenDictionary`2.GetValueRefOrNullRef(`0) -System.Collections.Frozen.FrozenDictionary`2.TryGetAlternateLookup``1(System.Collections.Frozen.FrozenDictionary{`0,`1}.AlternateLookup{``0}@) System.Collections.Frozen.FrozenDictionary`2.TryGetValue(`0,`1@) System.Collections.Frozen.FrozenDictionary`2.get_Comparer System.Collections.Frozen.FrozenDictionary`2.get_Count @@ -27,21 +20,14 @@ System.Collections.Frozen.FrozenDictionary`2.get_Item(`0) System.Collections.Frozen.FrozenDictionary`2.get_Keys System.Collections.Frozen.FrozenDictionary`2.get_Values System.Collections.Frozen.FrozenSet -System.Collections.Frozen.FrozenSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},System.ReadOnlySpan{``0}) -System.Collections.Frozen.FrozenSet.Create``1(System.ReadOnlySpan{``0}) System.Collections.Frozen.FrozenSet.ToFrozenSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) System.Collections.Frozen.FrozenSet`1 -System.Collections.Frozen.FrozenSet`1.AlternateLookup`1 -System.Collections.Frozen.FrozenSet`1.AlternateLookup`1.Contains(`1) -System.Collections.Frozen.FrozenSet`1.AlternateLookup`1.TryGetValue(`1,`0@) -System.Collections.Frozen.FrozenSet`1.AlternateLookup`1.get_Set System.Collections.Frozen.FrozenSet`1.Contains(`0) System.Collections.Frozen.FrozenSet`1.CopyTo(System.Span{`0}) System.Collections.Frozen.FrozenSet`1.CopyTo(`0[],System.Int32) System.Collections.Frozen.FrozenSet`1.Enumerator System.Collections.Frozen.FrozenSet`1.Enumerator.MoveNext System.Collections.Frozen.FrozenSet`1.Enumerator.get_Current -System.Collections.Frozen.FrozenSet`1.GetAlternateLookup``1 System.Collections.Frozen.FrozenSet`1.GetEnumerator System.Collections.Frozen.FrozenSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) System.Collections.Frozen.FrozenSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) @@ -49,7 +35,6 @@ System.Collections.Frozen.FrozenSet`1.IsSubsetOf(System.Collections.Generic.IEnu System.Collections.Frozen.FrozenSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) System.Collections.Frozen.FrozenSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) System.Collections.Frozen.FrozenSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -System.Collections.Frozen.FrozenSet`1.TryGetAlternateLookup``1(System.Collections.Frozen.FrozenSet{`0}.AlternateLookup{``0}@) System.Collections.Frozen.FrozenSet`1.TryGetValue(`0,`0@) System.Collections.Frozen.FrozenSet`1.get_Comparer System.Collections.Frozen.FrozenSet`1.get_Count diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt index 3caa7122e372a..62f756acc8c59 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Collections.txt @@ -54,16 +54,6 @@ System.Collections.Generic.Dictionary`2.#ctor(System.Int32) System.Collections.Generic.Dictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) System.Collections.Generic.Dictionary`2.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) System.Collections.Generic.Dictionary`2.Add(`0,`1) -System.Collections.Generic.Dictionary`2.AlternateLookup`1 -System.Collections.Generic.Dictionary`2.AlternateLookup`1.ContainsKey(`2) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.Remove(`2) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.Remove(`2,`0@,`1@) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.TryAdd(`2,`1) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.TryGetValue(`2,`0@,`1@) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.TryGetValue(`2,`1@) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.get_Dictionary -System.Collections.Generic.Dictionary`2.AlternateLookup`1.get_Item(`2) -System.Collections.Generic.Dictionary`2.AlternateLookup`1.set_Item(`2,`1) System.Collections.Generic.Dictionary`2.Clear System.Collections.Generic.Dictionary`2.ContainsKey(`0) System.Collections.Generic.Dictionary`2.ContainsValue(`1) @@ -72,7 +62,6 @@ System.Collections.Generic.Dictionary`2.Enumerator System.Collections.Generic.Dictionary`2.Enumerator.Dispose System.Collections.Generic.Dictionary`2.Enumerator.MoveNext System.Collections.Generic.Dictionary`2.Enumerator.get_Current -System.Collections.Generic.Dictionary`2.GetAlternateLookup``1 System.Collections.Generic.Dictionary`2.GetEnumerator System.Collections.Generic.Dictionary`2.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) System.Collections.Generic.Dictionary`2.KeyCollection @@ -91,7 +80,6 @@ System.Collections.Generic.Dictionary`2.Remove(`0,`1@) System.Collections.Generic.Dictionary`2.TrimExcess System.Collections.Generic.Dictionary`2.TrimExcess(System.Int32) System.Collections.Generic.Dictionary`2.TryAdd(`0,`1) -System.Collections.Generic.Dictionary`2.TryGetAlternateLookup``1(System.Collections.Generic.Dictionary{`0,`1}.AlternateLookup{``0}@) System.Collections.Generic.Dictionary`2.TryGetValue(`0,`1@) System.Collections.Generic.Dictionary`2.ValueCollection System.Collections.Generic.Dictionary`2.ValueCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) @@ -102,7 +90,6 @@ System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.MoveNext System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.get_Current System.Collections.Generic.Dictionary`2.ValueCollection.GetEnumerator System.Collections.Generic.Dictionary`2.ValueCollection.get_Count -System.Collections.Generic.Dictionary`2.get_Capacity System.Collections.Generic.Dictionary`2.get_Comparer System.Collections.Generic.Dictionary`2.get_Count System.Collections.Generic.Dictionary`2.get_Item(`0) @@ -124,12 +111,6 @@ System.Collections.Generic.HashSet`1.#ctor(System.Int32) System.Collections.Generic.HashSet`1.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) System.Collections.Generic.HashSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) System.Collections.Generic.HashSet`1.Add(`0) -System.Collections.Generic.HashSet`1.AlternateLookup`1 -System.Collections.Generic.HashSet`1.AlternateLookup`1.Add(`1) -System.Collections.Generic.HashSet`1.AlternateLookup`1.Contains(`1) -System.Collections.Generic.HashSet`1.AlternateLookup`1.Remove(`1) -System.Collections.Generic.HashSet`1.AlternateLookup`1.TryGetValue(`1,`0@) -System.Collections.Generic.HashSet`1.AlternateLookup`1.get_Set System.Collections.Generic.HashSet`1.Clear System.Collections.Generic.HashSet`1.Contains(`0) System.Collections.Generic.HashSet`1.CopyTo(`0[]) @@ -142,7 +123,6 @@ System.Collections.Generic.HashSet`1.Enumerator.Dispose System.Collections.Generic.HashSet`1.Enumerator.MoveNext System.Collections.Generic.HashSet`1.Enumerator.get_Current System.Collections.Generic.HashSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) -System.Collections.Generic.HashSet`1.GetAlternateLookup``1 System.Collections.Generic.HashSet`1.GetEnumerator System.Collections.Generic.HashSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) System.Collections.Generic.HashSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) @@ -157,11 +137,8 @@ System.Collections.Generic.HashSet`1.RemoveWhere(System.Predicate{`0}) System.Collections.Generic.HashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) System.Collections.Generic.HashSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) System.Collections.Generic.HashSet`1.TrimExcess -System.Collections.Generic.HashSet`1.TrimExcess(System.Int32) -System.Collections.Generic.HashSet`1.TryGetAlternateLookup``1(System.Collections.Generic.HashSet{`0}.AlternateLookup{``0}@) System.Collections.Generic.HashSet`1.TryGetValue(`0,`0@) System.Collections.Generic.HashSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) -System.Collections.Generic.HashSet`1.get_Capacity System.Collections.Generic.HashSet`1.get_Comparer System.Collections.Generic.HashSet`1.get_Count System.Collections.Generic.LinkedListNode`1 @@ -264,58 +241,6 @@ System.Collections.Generic.List`1.get_Count System.Collections.Generic.List`1.get_Item(System.Int32) System.Collections.Generic.List`1.set_Capacity(System.Int32) System.Collections.Generic.List`1.set_Item(System.Int32,`0) -System.Collections.Generic.OrderedDictionary`2 -System.Collections.Generic.OrderedDictionary`2.#ctor -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IEqualityComparer{`0}) -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IEqualityComparer{`0}) -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Collections.Generic.IEqualityComparer{`0}) -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Int32) -System.Collections.Generic.OrderedDictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -System.Collections.Generic.OrderedDictionary`2.Add(`0,`1) -System.Collections.Generic.OrderedDictionary`2.Clear -System.Collections.Generic.OrderedDictionary`2.ContainsKey(`0) -System.Collections.Generic.OrderedDictionary`2.ContainsValue(`1) -System.Collections.Generic.OrderedDictionary`2.EnsureCapacity(System.Int32) -System.Collections.Generic.OrderedDictionary`2.Enumerator -System.Collections.Generic.OrderedDictionary`2.Enumerator.MoveNext -System.Collections.Generic.OrderedDictionary`2.Enumerator.get_Current -System.Collections.Generic.OrderedDictionary`2.GetAt(System.Int32) -System.Collections.Generic.OrderedDictionary`2.GetEnumerator -System.Collections.Generic.OrderedDictionary`2.IndexOf(`0) -System.Collections.Generic.OrderedDictionary`2.Insert(System.Int32,`0,`1) -System.Collections.Generic.OrderedDictionary`2.KeyCollection -System.Collections.Generic.OrderedDictionary`2.KeyCollection.Contains(`0) -System.Collections.Generic.OrderedDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) -System.Collections.Generic.OrderedDictionary`2.KeyCollection.Enumerator -System.Collections.Generic.OrderedDictionary`2.KeyCollection.Enumerator.MoveNext -System.Collections.Generic.OrderedDictionary`2.KeyCollection.Enumerator.get_Current -System.Collections.Generic.OrderedDictionary`2.KeyCollection.GetEnumerator -System.Collections.Generic.OrderedDictionary`2.KeyCollection.get_Count -System.Collections.Generic.OrderedDictionary`2.Remove(`0) -System.Collections.Generic.OrderedDictionary`2.Remove(`0,`1@) -System.Collections.Generic.OrderedDictionary`2.RemoveAt(System.Int32) -System.Collections.Generic.OrderedDictionary`2.SetAt(System.Int32,`0,`1) -System.Collections.Generic.OrderedDictionary`2.SetAt(System.Int32,`1) -System.Collections.Generic.OrderedDictionary`2.TrimExcess -System.Collections.Generic.OrderedDictionary`2.TrimExcess(System.Int32) -System.Collections.Generic.OrderedDictionary`2.TryAdd(`0,`1) -System.Collections.Generic.OrderedDictionary`2.TryGetValue(`0,`1@) -System.Collections.Generic.OrderedDictionary`2.ValueCollection -System.Collections.Generic.OrderedDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) -System.Collections.Generic.OrderedDictionary`2.ValueCollection.Enumerator -System.Collections.Generic.OrderedDictionary`2.ValueCollection.Enumerator.MoveNext -System.Collections.Generic.OrderedDictionary`2.ValueCollection.Enumerator.get_Current -System.Collections.Generic.OrderedDictionary`2.ValueCollection.GetEnumerator -System.Collections.Generic.OrderedDictionary`2.ValueCollection.get_Count -System.Collections.Generic.OrderedDictionary`2.get_Capacity -System.Collections.Generic.OrderedDictionary`2.get_Comparer -System.Collections.Generic.OrderedDictionary`2.get_Count -System.Collections.Generic.OrderedDictionary`2.get_Item(`0) -System.Collections.Generic.OrderedDictionary`2.get_Keys -System.Collections.Generic.OrderedDictionary`2.get_Values -System.Collections.Generic.OrderedDictionary`2.set_Item(`0,`1) System.Collections.Generic.PriorityQueue`2 System.Collections.Generic.PriorityQueue`2.#ctor System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IComparer{`1}) @@ -332,7 +257,6 @@ System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Gener System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{`0},`1) System.Collections.Generic.PriorityQueue`2.EnsureCapacity(System.Int32) System.Collections.Generic.PriorityQueue`2.Peek -System.Collections.Generic.PriorityQueue`2.Remove(`0,`0@,`1@,System.Collections.Generic.IEqualityComparer{`0}) System.Collections.Generic.PriorityQueue`2.TrimExcess System.Collections.Generic.PriorityQueue`2.TryDequeue(`0@,`1@) System.Collections.Generic.PriorityQueue`2.TryPeek(`0@,`1@) @@ -364,10 +288,8 @@ System.Collections.Generic.Queue`1.GetEnumerator System.Collections.Generic.Queue`1.Peek System.Collections.Generic.Queue`1.ToArray System.Collections.Generic.Queue`1.TrimExcess -System.Collections.Generic.Queue`1.TrimExcess(System.Int32) System.Collections.Generic.Queue`1.TryDequeue(`0@) System.Collections.Generic.Queue`1.TryPeek(`0@) -System.Collections.Generic.Queue`1.get_Capacity System.Collections.Generic.Queue`1.get_Count System.Collections.Generic.ReferenceEqualityComparer System.Collections.Generic.ReferenceEqualityComparer.Equals(System.Object,System.Object) @@ -502,24 +424,9 @@ System.Collections.Generic.Stack`1.Pop System.Collections.Generic.Stack`1.Push(`0) System.Collections.Generic.Stack`1.ToArray System.Collections.Generic.Stack`1.TrimExcess -System.Collections.Generic.Stack`1.TrimExcess(System.Int32) System.Collections.Generic.Stack`1.TryPeek(`0@) System.Collections.Generic.Stack`1.TryPop(`0@) -System.Collections.Generic.Stack`1.get_Capacity System.Collections.Generic.Stack`1.get_Count -System.Collections.ObjectModel.ReadOnlySet`1 -System.Collections.ObjectModel.ReadOnlySet`1.#ctor(System.Collections.Generic.ISet{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.Contains(`0) -System.Collections.ObjectModel.ReadOnlySet`1.GetEnumerator -System.Collections.ObjectModel.ReadOnlySet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -System.Collections.ObjectModel.ReadOnlySet`1.get_Count -System.Collections.ObjectModel.ReadOnlySet`1.get_Empty -System.Collections.ObjectModel.ReadOnlySet`1.get_Set System.Collections.StructuralComparisons System.Collections.StructuralComparisons.get_StructuralComparer System.Collections.StructuralComparisons.get_StructuralEqualityComparer \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt index dea122b02f26e..85c524ab52cba 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Linq.txt @@ -1,7 +1,5 @@ # Generated, do not update manually System.Linq.Enumerable -System.Linq.Enumerable.AggregateBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``0,``2},System.Collections.Generic.IEqualityComparer{``1}) -System.Linq.Enumerable.AggregateBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},``2,System.Func{``2,``0,``2},System.Collections.Generic.IEqualityComparer{``1}) System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0}) System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1}) System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2}) @@ -35,7 +33,6 @@ System.Linq.Enumerable.Chunk``1(System.Collections.Generic.IEnumerable{``0},Syst System.Linq.Enumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0) System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) -System.Linq.Enumerable.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0}) System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0}) @@ -69,7 +66,6 @@ System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},Sy System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3},System.Collections.Generic.IEqualityComparer{``1}) System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3}) System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2}) -System.Linq.Enumerable.Index``1(System.Collections.Generic.IEnumerable{``0}) System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt index aaf32c8766bbc..cb02fc218dc5f 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/System.Runtime.txt @@ -202,9 +202,6 @@ System.Array.CreateInstance(System.Type,System.Int32,System.Int32,System.Int32) System.Array.CreateInstance(System.Type,System.Int32[]) System.Array.CreateInstance(System.Type,System.Int32[],System.Int32[]) System.Array.CreateInstance(System.Type,System.Int64[]) -System.Array.CreateInstanceFromArrayType(System.Type,System.Int32) -System.Array.CreateInstanceFromArrayType(System.Type,System.Int32[]) -System.Array.CreateInstanceFromArrayType(System.Type,System.Int32[],System.Int32[]) System.Array.Empty``1 System.Array.Exists``1(``0[],System.Predicate{``0}) System.Array.Fill``1(``0[],``0) @@ -405,12 +402,10 @@ System.BitConverter.GetBytes(System.Boolean) System.BitConverter.GetBytes(System.Char) System.BitConverter.GetBytes(System.Double) System.BitConverter.GetBytes(System.Half) -System.BitConverter.GetBytes(System.Int128) System.BitConverter.GetBytes(System.Int16) System.BitConverter.GetBytes(System.Int32) System.BitConverter.GetBytes(System.Int64) System.BitConverter.GetBytes(System.Single) -System.BitConverter.GetBytes(System.UInt128) System.BitConverter.GetBytes(System.UInt16) System.BitConverter.GetBytes(System.UInt32) System.BitConverter.GetBytes(System.UInt64) @@ -430,8 +425,6 @@ System.BitConverter.ToDouble(System.Byte[],System.Int32) System.BitConverter.ToDouble(System.ReadOnlySpan{System.Byte}) System.BitConverter.ToHalf(System.Byte[],System.Int32) System.BitConverter.ToHalf(System.ReadOnlySpan{System.Byte}) -System.BitConverter.ToInt128(System.Byte[],System.Int32) -System.BitConverter.ToInt128(System.ReadOnlySpan{System.Byte}) System.BitConverter.ToInt16(System.Byte[],System.Int32) System.BitConverter.ToInt16(System.ReadOnlySpan{System.Byte}) System.BitConverter.ToInt32(System.Byte[],System.Int32) @@ -443,8 +436,6 @@ System.BitConverter.ToSingle(System.ReadOnlySpan{System.Byte}) System.BitConverter.ToString(System.Byte[]) System.BitConverter.ToString(System.Byte[],System.Int32) System.BitConverter.ToString(System.Byte[],System.Int32,System.Int32) -System.BitConverter.ToUInt128(System.Byte[],System.Int32) -System.BitConverter.ToUInt128(System.ReadOnlySpan{System.Byte}) System.BitConverter.ToUInt16(System.Byte[],System.Int32) System.BitConverter.ToUInt16(System.ReadOnlySpan{System.Byte}) System.BitConverter.ToUInt32(System.Byte[],System.Int32) @@ -455,12 +446,10 @@ System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Boolean) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Char) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Double) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Half) -System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int128) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int16) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int32) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int64) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Single) -System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt128) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt16) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt32) System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt64) @@ -529,7 +518,6 @@ System.Buffers.ReadOnlySpanAction`2.Invoke(System.ReadOnlySpan{`0},`1) System.Buffers.SearchValues System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Byte}) System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Char}) -System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.String},System.StringComparison) System.Buffers.SearchValues`1 System.Buffers.SearchValues`1.Contains(`0) System.Buffers.SpanAction`2 @@ -548,32 +536,6 @@ System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte}) System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte},System.Int32@) System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char}) System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char},System.Int32@) -System.Buffers.Text.Base64Url -System.Buffers.Text.Base64Url.DecodeFromChars(System.ReadOnlySpan{System.Char}) -System.Buffers.Text.Base64Url.DecodeFromChars(System.ReadOnlySpan{System.Char},System.Span{System.Byte}) -System.Buffers.Text.Base64Url.DecodeFromChars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) -System.Buffers.Text.Base64Url.DecodeFromUtf8(System.ReadOnlySpan{System.Byte}) -System.Buffers.Text.Base64Url.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte}) -System.Buffers.Text.Base64Url.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) -System.Buffers.Text.Base64Url.DecodeFromUtf8InPlace(System.Span{System.Byte}) -System.Buffers.Text.Base64Url.EncodeToChars(System.ReadOnlySpan{System.Byte}) -System.Buffers.Text.Base64Url.EncodeToChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char}) -System.Buffers.Text.Base64Url.EncodeToChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Int32@,System.Boolean) -System.Buffers.Text.Base64Url.EncodeToString(System.ReadOnlySpan{System.Byte}) -System.Buffers.Text.Base64Url.EncodeToUtf8(System.ReadOnlySpan{System.Byte}) -System.Buffers.Text.Base64Url.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte}) -System.Buffers.Text.Base64Url.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) -System.Buffers.Text.Base64Url.GetEncodedLength(System.Int32) -System.Buffers.Text.Base64Url.GetMaxDecodedLength(System.Int32) -System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Byte}) -System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Byte},System.Int32@) -System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Char}) -System.Buffers.Text.Base64Url.IsValid(System.ReadOnlySpan{System.Char},System.Int32@) -System.Buffers.Text.Base64Url.TryDecodeFromChars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) -System.Buffers.Text.Base64Url.TryDecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) -System.Buffers.Text.Base64Url.TryEncodeToChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) -System.Buffers.Text.Base64Url.TryEncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) -System.Buffers.Text.Base64Url.TryEncodeToUtf8InPlace(System.Span{System.Byte},System.Int32,System.Int32@) System.Byte System.Byte.Clamp(System.Byte,System.Byte,System.Byte) System.Byte.CompareTo(System.Byte) @@ -772,10 +734,6 @@ System.Collections.DictionaryEntry.get_Key System.Collections.DictionaryEntry.get_Value System.Collections.DictionaryEntry.set_Key(System.Object) System.Collections.DictionaryEntry.set_Value(System.Object) -System.Collections.Generic.IAlternateEqualityComparer`2 -System.Collections.Generic.IAlternateEqualityComparer`2.Create(`0) -System.Collections.Generic.IAlternateEqualityComparer`2.Equals(`0,`1) -System.Collections.Generic.IAlternateEqualityComparer`2.GetHashCode(`0) System.Collections.Generic.IAsyncEnumerable`1 System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken) System.Collections.Generic.IAsyncEnumerator`1 @@ -1066,9 +1024,7 @@ System.Convert.DBNull System.Convert.FromBase64CharArray(System.Char[],System.Int32,System.Int32) System.Convert.FromBase64String(System.String) System.Convert.FromHexString(System.ReadOnlySpan{System.Char}) -System.Convert.FromHexString(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@) System.Convert.FromHexString(System.String) -System.Convert.FromHexString(System.String,System.Span{System.Byte},System.Int32@,System.Int32@) System.Convert.GetTypeCode(System.Object) System.Convert.IsDBNull(System.Object) System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) @@ -1190,9 +1146,6 @@ System.Convert.ToDouble(System.UInt64) System.Convert.ToHexString(System.Byte[]) System.Convert.ToHexString(System.Byte[],System.Int32,System.Int32) System.Convert.ToHexString(System.ReadOnlySpan{System.Byte}) -System.Convert.ToHexStringLower(System.Byte[]) -System.Convert.ToHexStringLower(System.Byte[],System.Int32,System.Int32) -System.Convert.ToHexStringLower(System.ReadOnlySpan{System.Byte}) System.Convert.ToInt16(System.Boolean) System.Convert.ToInt16(System.Byte) System.Convert.ToInt16(System.Char) @@ -1383,8 +1336,6 @@ System.Convert.ToUInt64(System.UInt64) System.Convert.TryFromBase64Chars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) System.Convert.TryFromBase64String(System.String,System.Span{System.Byte},System.Int32@) System.Convert.TryToBase64Chars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Base64FormattingOptions) -System.Convert.TryToHexString(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) -System.Convert.TryToHexStringLower(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) System.Converter`2 System.Converter`2.#ctor(System.Object,System.IntPtr) System.Converter`2.BeginInvoke(`0,System.AsyncCallback,System.Object) @@ -1707,8 +1658,6 @@ System.Decimal.Clamp(System.Decimal,System.Decimal,System.Decimal) System.Decimal.Compare(System.Decimal,System.Decimal) System.Decimal.CompareTo(System.Decimal) System.Decimal.CompareTo(System.Object) -System.Decimal.ConvertToIntegerNative``1(System.Decimal) -System.Decimal.ConvertToInteger``1(System.Decimal) System.Decimal.CopySign(System.Decimal,System.Decimal) System.Decimal.CreateChecked``1(``0) System.Decimal.CreateSaturating``1(``0) @@ -1827,7 +1776,6 @@ System.Delegate.#ctor(System.Type,System.String) System.Delegate.Clone System.Delegate.Combine(System.Delegate,System.Delegate) System.Delegate.Combine(System.Delegate[]) -System.Delegate.Combine(System.ReadOnlySpan{System.Delegate}) System.Delegate.CombineImpl(System.Delegate) System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo) System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boolean) @@ -1841,20 +1789,14 @@ System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Bool System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean,System.Boolean) System.Delegate.DynamicInvoke(System.Object[]) System.Delegate.DynamicInvokeImpl(System.Object[]) -System.Delegate.EnumerateInvocationList``1(``0) System.Delegate.Equals(System.Object) System.Delegate.GetHashCode System.Delegate.GetInvocationList System.Delegate.GetMethodImpl System.Delegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -System.Delegate.InvocationListEnumerator`1 -System.Delegate.InvocationListEnumerator`1.GetEnumerator -System.Delegate.InvocationListEnumerator`1.MoveNext -System.Delegate.InvocationListEnumerator`1.get_Current System.Delegate.Remove(System.Delegate,System.Delegate) System.Delegate.RemoveAll(System.Delegate,System.Delegate) System.Delegate.RemoveImpl(System.Delegate) -System.Delegate.get_HasSingleTarget System.Delegate.get_Method System.Delegate.get_Target System.Delegate.op_Equality(System.Delegate,System.Delegate) @@ -1916,12 +1858,6 @@ System.Diagnostics.CodeAnalysis.ExperimentalAttribute.#ctor(System.String) System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_DiagnosticId System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_UrlFormat System.Diagnostics.CodeAnalysis.ExperimentalAttribute.set_UrlFormat(System.String) -System.Diagnostics.CodeAnalysis.FeatureGuardAttribute -System.Diagnostics.CodeAnalysis.FeatureGuardAttribute.#ctor(System.Type) -System.Diagnostics.CodeAnalysis.FeatureGuardAttribute.get_FeatureType -System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute -System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute.#ctor(System.String) -System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute.get_SwitchName System.Diagnostics.CodeAnalysis.MaybeNullAttribute System.Diagnostics.CodeAnalysis.MaybeNullAttribute.#ctor System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute @@ -2069,8 +2005,6 @@ System.Diagnostics.DebuggerBrowsableState System.Diagnostics.DebuggerBrowsableState.Collapsed System.Diagnostics.DebuggerBrowsableState.Never System.Diagnostics.DebuggerBrowsableState.RootHidden -System.Diagnostics.DebuggerDisableUserUnhandledExceptionsAttribute -System.Diagnostics.DebuggerDisableUserUnhandledExceptionsAttribute.#ctor System.Diagnostics.DebuggerDisplayAttribute System.Diagnostics.DebuggerDisplayAttribute.#ctor(System.String) System.Diagnostics.DebuggerDisplayAttribute.get_Name @@ -2161,8 +2095,6 @@ System.Double.Ceiling(System.Double) System.Double.Clamp(System.Double,System.Double,System.Double) System.Double.CompareTo(System.Double) System.Double.CompareTo(System.Object) -System.Double.ConvertToIntegerNative``1(System.Double) -System.Double.ConvertToInteger``1(System.Double) System.Double.CopySign(System.Double,System.Double) System.Double.Cos(System.Double) System.Double.CosPi(System.Double) @@ -2220,7 +2152,6 @@ System.Double.MinMagnitude(System.Double,System.Double) System.Double.MinMagnitudeNumber(System.Double,System.Double) System.Double.MinNumber(System.Double,System.Double) System.Double.MinValue -System.Double.MultiplyAddEstimate(System.Double,System.Double,System.Double) System.Double.NaN System.Double.NegativeInfinity System.Double.NegativeZero @@ -3368,8 +3299,6 @@ System.Guid.#ctor(System.String) System.Guid.#ctor(System.UInt32,System.UInt16,System.UInt16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) System.Guid.CompareTo(System.Guid) System.Guid.CompareTo(System.Object) -System.Guid.CreateVersion7 -System.Guid.CreateVersion7(System.DateTimeOffset) System.Guid.Empty System.Guid.Equals(System.Guid) System.Guid.Equals(System.Object) @@ -3396,9 +3325,6 @@ System.Guid.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{S System.Guid.TryParseExact(System.String,System.String,System.Guid@) System.Guid.TryWriteBytes(System.Span{System.Byte}) System.Guid.TryWriteBytes(System.Span{System.Byte},System.Boolean,System.Int32@) -System.Guid.get_AllBitsSet -System.Guid.get_Variant -System.Guid.get_Version System.Guid.op_Equality(System.Guid,System.Guid) System.Guid.op_GreaterThan(System.Guid,System.Guid) System.Guid.op_GreaterThanOrEqual(System.Guid,System.Guid) @@ -3425,8 +3351,6 @@ System.Half.Ceiling(System.Half) System.Half.Clamp(System.Half,System.Half,System.Half) System.Half.CompareTo(System.Half) System.Half.CompareTo(System.Object) -System.Half.ConvertToIntegerNative``1(System.Half) -System.Half.ConvertToInteger``1(System.Half) System.Half.CopySign(System.Half,System.Half) System.Half.Cos(System.Half) System.Half.CosPi(System.Half) @@ -3479,7 +3403,6 @@ System.Half.Min(System.Half,System.Half) System.Half.MinMagnitude(System.Half,System.Half) System.Half.MinMagnitudeNumber(System.Half,System.Half) System.Half.MinNumber(System.Half,System.Half) -System.Half.MultiplyAddEstimate(System.Half,System.Half,System.Half) System.Half.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) System.Half.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) System.Half.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) @@ -3889,7 +3812,6 @@ System.Int16.TryParse(System.String,System.IFormatProvider,System.Int16@) System.Int16.TryParse(System.String,System.Int16@) System.Int32 System.Int32.Abs(System.Int32) -System.Int32.BigMul(System.Int32,System.Int32) System.Int32.Clamp(System.Int32,System.Int32,System.Int32) System.Int32.CompareTo(System.Int32) System.Int32.CompareTo(System.Object) @@ -3945,7 +3867,6 @@ System.Int32.TryParse(System.String,System.IFormatProvider,System.Int32@) System.Int32.TryParse(System.String,System.Int32@) System.Int64 System.Int64.Abs(System.Int64) -System.Int64.BigMul(System.Int64,System.Int64) System.Int64.Clamp(System.Int64,System.Int64,System.Int64) System.Int64.CompareTo(System.Int64) System.Int64.CompareTo(System.Object) @@ -4131,10 +4052,7 @@ System.Math.Atan(System.Double) System.Math.Atan2(System.Double,System.Double) System.Math.Atanh(System.Double) System.Math.BigMul(System.Int32,System.Int32) -System.Math.BigMul(System.Int64,System.Int64) System.Math.BigMul(System.Int64,System.Int64,System.Int64@) -System.Math.BigMul(System.UInt32,System.UInt32) -System.Math.BigMul(System.UInt64,System.UInt64) System.Math.BigMul(System.UInt64,System.UInt64,System.UInt64@) System.Math.BitDecrement(System.Double) System.Math.BitIncrement(System.Double) @@ -4531,8 +4449,6 @@ System.Numerics.IFloatingPointIeee754`1.get_NegativeZero System.Numerics.IFloatingPointIeee754`1.get_PositiveInfinity System.Numerics.IFloatingPoint`1 System.Numerics.IFloatingPoint`1.Ceiling(`0) -System.Numerics.IFloatingPoint`1.ConvertToIntegerNative``1(`0) -System.Numerics.IFloatingPoint`1.ConvertToInteger``1(`0) System.Numerics.IFloatingPoint`1.Floor(`0) System.Numerics.IFloatingPoint`1.GetExponentByteCount System.Numerics.IFloatingPoint`1.GetExponentShortestBitLength @@ -4613,7 +4529,6 @@ System.Numerics.INumberBase`1.MaxMagnitude(`0,`0) System.Numerics.INumberBase`1.MaxMagnitudeNumber(`0,`0) System.Numerics.INumberBase`1.MinMagnitude(`0,`0) System.Numerics.INumberBase`1.MinMagnitudeNumber(`0,`0) -System.Numerics.INumberBase`1.MultiplyAddEstimate(`0,`0,`0) System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) System.Numerics.INumberBase`1.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) @@ -4850,7 +4765,6 @@ System.ReadOnlySpan`1.#ctor(System.Void*,System.Int32) System.ReadOnlySpan`1.#ctor(`0@) System.ReadOnlySpan`1.#ctor(`0[]) System.ReadOnlySpan`1.#ctor(`0[],System.Int32,System.Int32) -System.ReadOnlySpan`1.CastUp``1(System.ReadOnlySpan{``0}) System.ReadOnlySpan`1.CopyTo(System.Span{`0}) System.ReadOnlySpan`1.Enumerator System.ReadOnlySpan`1.Enumerator.MoveNext @@ -4952,8 +4866,6 @@ System.Runtime.CompilerServices.CallConvStdcall System.Runtime.CompilerServices.CallConvStdcall.#ctor System.Runtime.CompilerServices.CallConvSuppressGCTransition System.Runtime.CompilerServices.CallConvSuppressGCTransition.#ctor -System.Runtime.CompilerServices.CallConvSwift -System.Runtime.CompilerServices.CallConvSwift.#ctor System.Runtime.CompilerServices.CallConvThiscall System.Runtime.CompilerServices.CallConvThiscall.#ctor System.Runtime.CompilerServices.CallerArgumentExpressionAttribute @@ -5157,11 +5069,6 @@ System.Runtime.CompilerServices.NullableContextAttribute.Flag System.Runtime.CompilerServices.NullablePublicOnlyAttribute System.Runtime.CompilerServices.NullablePublicOnlyAttribute.#ctor(System.Boolean) System.Runtime.CompilerServices.NullablePublicOnlyAttribute.IncludesInternals -System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute -System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute.#ctor(System.Int32) -System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute.get_Priority -System.Runtime.CompilerServices.ParamCollectionAttribute -System.Runtime.CompilerServices.ParamCollectionAttribute.#ctor System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) @@ -5199,7 +5106,6 @@ System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.get_WrapNonExcepti System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.set_WrapNonExceptionThrows(System.Boolean) System.Runtime.CompilerServices.RuntimeFeature System.Runtime.CompilerServices.RuntimeFeature.ByRefFields -System.Runtime.CompilerServices.RuntimeFeature.ByRefLikeGenerics System.Runtime.CompilerServices.RuntimeFeature.CovariantReturnsOfClasses System.Runtime.CompilerServices.RuntimeFeature.DefaultImplementationsOfInterfaces System.Runtime.CompilerServices.RuntimeFeature.IsSupported(System.String) @@ -5211,7 +5117,6 @@ System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeCompiled System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeSupported System.Runtime.CompilerServices.RuntimeHelpers System.Runtime.CompilerServices.RuntimeHelpers.AllocateTypeAssociatedMemory(System.Type,System.Int32) -System.Runtime.CompilerServices.RuntimeHelpers.Box(System.Byte@,System.RuntimeTypeHandle) System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.#ctor(System.Object,System.IntPtr) System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.BeginInvoke(System.Object,System.Boolean,System.AsyncCallback,System.Object) @@ -5236,7 +5141,6 @@ System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMetho System.Runtime.CompilerServices.RuntimeHelpers.ProbeForSufficientStack System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(System.RuntimeTypeHandle) System.Runtime.CompilerServices.RuntimeHelpers.RunModuleConstructor(System.ModuleHandle) -System.Runtime.CompilerServices.RuntimeHelpers.SizeOf(System.RuntimeTypeHandle) System.Runtime.CompilerServices.RuntimeHelpers.TryCode System.Runtime.CompilerServices.RuntimeHelpers.TryCode.#ctor(System.Object,System.IntPtr) System.Runtime.CompilerServices.RuntimeHelpers.TryCode.BeginInvoke(System.Object,System.AsyncCallback,System.Object) @@ -5479,8 +5383,6 @@ System.Single.Ceiling(System.Single) System.Single.Clamp(System.Single,System.Single,System.Single) System.Single.CompareTo(System.Object) System.Single.CompareTo(System.Single) -System.Single.ConvertToIntegerNative``1(System.Single) -System.Single.ConvertToInteger``1(System.Single) System.Single.CopySign(System.Single,System.Single) System.Single.Cos(System.Single) System.Single.CosPi(System.Single) @@ -5538,7 +5440,6 @@ System.Single.MinMagnitude(System.Single,System.Single) System.Single.MinMagnitudeNumber(System.Single,System.Single) System.Single.MinNumber(System.Single,System.Single) System.Single.MinValue -System.Single.MultiplyAddEstimate(System.Single,System.Single,System.Single) System.Single.NaN System.Single.NegativeInfinity System.Single.NegativeZero @@ -5661,8 +5562,6 @@ System.String.Concat(System.Object[]) System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -System.String.Concat(System.ReadOnlySpan{System.Object}) -System.String.Concat(System.ReadOnlySpan{System.String}) System.String.Concat(System.String,System.String) System.String.Concat(System.String,System.String,System.String) System.String.Concat(System.String,System.String,System.String,System.String) @@ -5693,14 +5592,12 @@ System.String.Format(System.IFormatProvider,System.String,System.Object) System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object) System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) System.String.Format(System.IFormatProvider,System.String,System.Object[]) -System.String.Format(System.IFormatProvider,System.String,System.ReadOnlySpan{System.Object}) System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) System.String.Format(System.String,System.Object) System.String.Format(System.String,System.Object,System.Object) System.String.Format(System.String,System.Object,System.Object,System.Object) System.String.Format(System.String,System.Object[]) -System.String.Format(System.String,System.ReadOnlySpan{System.Object}) System.String.Format``1(System.IFormatProvider,System.Text.CompositeFormat,``0) System.String.Format``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) System.String.Format``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) @@ -5732,14 +5629,10 @@ System.String.IsNormalized(System.Text.NormalizationForm) System.String.IsNullOrEmpty(System.String) System.String.IsNullOrWhiteSpace(System.String) System.String.Join(System.Char,System.Object[]) -System.String.Join(System.Char,System.ReadOnlySpan{System.Object}) -System.String.Join(System.Char,System.ReadOnlySpan{System.String}) System.String.Join(System.Char,System.String[]) System.String.Join(System.Char,System.String[],System.Int32,System.Int32) System.String.Join(System.String,System.Collections.Generic.IEnumerable{System.String}) System.String.Join(System.String,System.Object[]) -System.String.Join(System.String,System.ReadOnlySpan{System.Object}) -System.String.Join(System.String,System.ReadOnlySpan{System.String}) System.String.Join(System.String,System.String[]) System.String.Join(System.String,System.String[],System.Int32,System.Int32) System.String.Join``1(System.Char,System.Collections.Generic.IEnumerable{``0}) @@ -5776,7 +5669,6 @@ System.String.Split(System.Char[]) System.String.Split(System.Char[],System.Int32) System.String.Split(System.Char[],System.Int32,System.StringSplitOptions) System.String.Split(System.Char[],System.StringSplitOptions) -System.String.Split(System.ReadOnlySpan{System.Char}) System.String.Split(System.String,System.Int32,System.StringSplitOptions) System.String.Split(System.String,System.StringSplitOptions) System.String.Split(System.String[],System.Int32,System.StringSplitOptions) @@ -6213,14 +6105,12 @@ System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,Syst System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object) System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object[]) -System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.ReadOnlySpan{System.Object}) System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) System.Text.StringBuilder.AppendFormat(System.String,System.Object) System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object) System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object,System.Object) System.Text.StringBuilder.AppendFormat(System.String,System.Object[]) -System.Text.StringBuilder.AppendFormat(System.String,System.ReadOnlySpan{System.Object}) System.Text.StringBuilder.AppendFormat``1(System.IFormatProvider,System.Text.CompositeFormat,``0) System.Text.StringBuilder.AppendFormat``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) System.Text.StringBuilder.AppendFormat``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) @@ -6238,12 +6128,8 @@ System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0 System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.String) System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendLiteral(System.String) System.Text.StringBuilder.AppendJoin(System.Char,System.Object[]) -System.Text.StringBuilder.AppendJoin(System.Char,System.ReadOnlySpan{System.Object}) -System.Text.StringBuilder.AppendJoin(System.Char,System.ReadOnlySpan{System.String}) System.Text.StringBuilder.AppendJoin(System.Char,System.String[]) System.Text.StringBuilder.AppendJoin(System.String,System.Object[]) -System.Text.StringBuilder.AppendJoin(System.String,System.ReadOnlySpan{System.Object}) -System.Text.StringBuilder.AppendJoin(System.String,System.ReadOnlySpan{System.String}) System.Text.StringBuilder.AppendJoin(System.String,System.String[]) System.Text.StringBuilder.AppendJoin``1(System.Char,System.Collections.Generic.IEnumerable{``0}) System.Text.StringBuilder.AppendJoin``1(System.String,System.Collections.Generic.IEnumerable{``0}) @@ -6284,8 +6170,6 @@ System.Text.StringBuilder.Insert(System.Int32,System.UInt64) System.Text.StringBuilder.Remove(System.Int32,System.Int32) System.Text.StringBuilder.Replace(System.Char,System.Char) System.Text.StringBuilder.Replace(System.Char,System.Char,System.Int32,System.Int32) -System.Text.StringBuilder.Replace(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -System.Text.StringBuilder.Replace(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Int32,System.Int32) System.Text.StringBuilder.Replace(System.String,System.String) System.Text.StringBuilder.Replace(System.String,System.String,System.Int32,System.Int32) System.Text.StringBuilder.ToString @@ -6427,13 +6311,11 @@ System.Threading.Tasks.TaskCompletionSource.SetCanceled System.Threading.Tasks.TaskCompletionSource.SetCanceled(System.Threading.CancellationToken) System.Threading.Tasks.TaskCompletionSource.SetException(System.Collections.Generic.IEnumerable{System.Exception}) System.Threading.Tasks.TaskCompletionSource.SetException(System.Exception) -System.Threading.Tasks.TaskCompletionSource.SetFromTask(System.Threading.Tasks.Task) System.Threading.Tasks.TaskCompletionSource.SetResult System.Threading.Tasks.TaskCompletionSource.TrySetCanceled System.Threading.Tasks.TaskCompletionSource.TrySetCanceled(System.Threading.CancellationToken) System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Exception) -System.Threading.Tasks.TaskCompletionSource.TrySetFromTask(System.Threading.Tasks.Task) System.Threading.Tasks.TaskCompletionSource.TrySetResult System.Threading.Tasks.TaskCompletionSource.get_Task System.Threading.Tasks.TaskCompletionSource`1 @@ -6445,13 +6327,11 @@ System.Threading.Tasks.TaskCompletionSource`1.SetCanceled System.Threading.Tasks.TaskCompletionSource`1.SetCanceled(System.Threading.CancellationToken) System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception}) System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception) -System.Threading.Tasks.TaskCompletionSource`1.SetFromTask(System.Threading.Tasks.Task{`0}) System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0) System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken) System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception) -System.Threading.Tasks.TaskCompletionSource`1.TrySetFromTask(System.Threading.Tasks.Task{`0}) System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0) System.Threading.Tasks.TaskCompletionSource`1.get_Task System.Threading.Tasks.TaskContinuationOptions @@ -6657,37 +6537,15 @@ System.TimeSpan.Equals(System.Object) System.TimeSpan.Equals(System.TimeSpan) System.TimeSpan.Equals(System.TimeSpan,System.TimeSpan) System.TimeSpan.FromDays(System.Double) -System.TimeSpan.FromDays(System.Int32) -System.TimeSpan.FromDays(System.Int32,System.Int32,System.Int64,System.Int64,System.Int64,System.Int64) System.TimeSpan.FromHours(System.Double) -System.TimeSpan.FromHours(System.Int32) -System.TimeSpan.FromHours(System.Int32,System.Int64,System.Int64,System.Int64,System.Int64) System.TimeSpan.FromMicroseconds(System.Double) -System.TimeSpan.FromMicroseconds(System.Int64) System.TimeSpan.FromMilliseconds(System.Double) -System.TimeSpan.FromMilliseconds(System.Int64,System.Int64) System.TimeSpan.FromMinutes(System.Double) -System.TimeSpan.FromMinutes(System.Int64) -System.TimeSpan.FromMinutes(System.Int64,System.Int64,System.Int64,System.Int64) System.TimeSpan.FromSeconds(System.Double) -System.TimeSpan.FromSeconds(System.Int64) -System.TimeSpan.FromSeconds(System.Int64,System.Int64,System.Int64) System.TimeSpan.FromTicks(System.Int64) System.TimeSpan.GetHashCode -System.TimeSpan.HoursPerDay System.TimeSpan.MaxValue -System.TimeSpan.MicrosecondsPerDay -System.TimeSpan.MicrosecondsPerHour -System.TimeSpan.MicrosecondsPerMillisecond -System.TimeSpan.MicrosecondsPerMinute -System.TimeSpan.MicrosecondsPerSecond -System.TimeSpan.MillisecondsPerDay -System.TimeSpan.MillisecondsPerHour -System.TimeSpan.MillisecondsPerMinute -System.TimeSpan.MillisecondsPerSecond System.TimeSpan.MinValue -System.TimeSpan.MinutesPerDay -System.TimeSpan.MinutesPerHour System.TimeSpan.Multiply(System.Double) System.TimeSpan.NanosecondsPerTick System.TimeSpan.Negate @@ -6700,9 +6558,6 @@ System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider) System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles) System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider) System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) -System.TimeSpan.SecondsPerDay -System.TimeSpan.SecondsPerHour -System.TimeSpan.SecondsPerMinute System.TimeSpan.Subtract(System.TimeSpan) System.TimeSpan.TicksPerDay System.TimeSpan.TicksPerHour @@ -7235,7 +7090,6 @@ System.UInt16.TryParse(System.String,System.Globalization.NumberStyles,System.IF System.UInt16.TryParse(System.String,System.IFormatProvider,System.UInt16@) System.UInt16.TryParse(System.String,System.UInt16@) System.UInt32 -System.UInt32.BigMul(System.UInt32,System.UInt32) System.UInt32.Clamp(System.UInt32,System.UInt32,System.UInt32) System.UInt32.CompareTo(System.Object) System.UInt32.CompareTo(System.UInt32) @@ -7285,7 +7139,6 @@ System.UInt32.TryParse(System.String,System.Globalization.NumberStyles,System.IF System.UInt32.TryParse(System.String,System.IFormatProvider,System.UInt32@) System.UInt32.TryParse(System.String,System.UInt32@) System.UInt64 -System.UInt64.BigMul(System.UInt64,System.UInt64) System.UInt64.Clamp(System.UInt64,System.UInt64,System.UInt64) System.UInt64.CompareTo(System.Object) System.UInt64.CompareTo(System.UInt64) @@ -7431,9 +7284,7 @@ System.Uri.CheckSchemeName(System.String) System.Uri.CheckSecurity System.Uri.Compare(System.Uri,System.Uri,System.UriComponents,System.UriFormat,System.StringComparison) System.Uri.Equals(System.Object) -System.Uri.Equals(System.Uri) System.Uri.Escape -System.Uri.EscapeDataString(System.ReadOnlySpan{System.Char}) System.Uri.EscapeDataString(System.String) System.Uri.EscapeString(System.String) System.Uri.EscapeUriString(System.String) @@ -7461,11 +7312,8 @@ System.Uri.TryCreate(System.String,System.UriCreationOptions@,System.Uri@) System.Uri.TryCreate(System.String,System.UriKind,System.Uri@) System.Uri.TryCreate(System.Uri,System.String,System.Uri@) System.Uri.TryCreate(System.Uri,System.Uri,System.Uri@) -System.Uri.TryEscapeDataString(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) System.Uri.TryFormat(System.Span{System.Char},System.Int32@) -System.Uri.TryUnescapeDataString(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) System.Uri.Unescape(System.String) -System.Uri.UnescapeDataString(System.ReadOnlySpan{System.Char}) System.Uri.UnescapeDataString(System.String) System.Uri.UriSchemeFile System.Uri.UriSchemeFtp diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj b/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj index b08e786e53a46..e241734e01deb 100644 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj +++ b/src/Tools/SemanticSearch/ReferenceAssemblies/SemanticSearch.ReferenceAssemblies.csproj @@ -1,7 +1,8 @@  Library - $(NetRoslyn) + + $(NetVS) <_BuildTaskTfm Condition="'$(MSBuildRuntimeType)' != 'Core'">net472 <_BuildTaskTfm Condition="'$(MSBuildRuntimeType)' == 'Core'">$(NetRoslyn) diff --git a/src/Workspaces/CSharpTest/Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests.csproj b/src/Workspaces/CSharpTest/Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests.csproj index a80f83971dc71..65dae6561ce44 100644 --- a/src/Workspaces/CSharpTest/Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests.csproj +++ b/src/Workspaces/CSharpTest/Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests.csproj @@ -4,7 +4,8 @@ Library Microsoft.CodeAnalysis.CSharp.UnitTests - $(NetRoslyn);net472 + + $(NetVSShared);net472 diff --git a/src/Workspaces/CoreTest/Microsoft.CodeAnalysis.Workspaces.UnitTests.csproj b/src/Workspaces/CoreTest/Microsoft.CodeAnalysis.Workspaces.UnitTests.csproj index b5b2a51d4a127..df55ccc847f10 100644 --- a/src/Workspaces/CoreTest/Microsoft.CodeAnalysis.Workspaces.UnitTests.csproj +++ b/src/Workspaces/CoreTest/Microsoft.CodeAnalysis.Workspaces.UnitTests.csproj @@ -3,7 +3,8 @@ Library - $(NetRoslyn);net472 + + $(NetVSShared);net472 Microsoft.CodeAnalysis.UnitTests diff --git a/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj b/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj index 5082e3b3765da..633d78b7eb8f1 100644 --- a/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj +++ b/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj @@ -4,7 +4,8 @@ Library Microsoft.CodeAnalysis.UnitTests - $(NetRoslynAll);net472 + + $(NetVSShared);net472 false true true diff --git a/src/Workspaces/Remote/ServiceHubTest/Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests.csproj b/src/Workspaces/Remote/ServiceHubTest/Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests.csproj index 4b6681624252b..cf1a0699f5eff 100644 --- a/src/Workspaces/Remote/ServiceHubTest/Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests.csproj +++ b/src/Workspaces/Remote/ServiceHubTest/Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests.csproj @@ -3,7 +3,8 @@ Library - $(NetRoslyn);net472 + + $(NetVS);net472 Microsoft.CodeAnalysis.UnitTests diff --git a/src/Workspaces/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests.vbproj b/src/Workspaces/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests.vbproj index 5b78c77b0e126..16cbc5e051c2e 100644 --- a/src/Workspaces/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests.vbproj +++ b/src/Workspaces/VisualBasicTest/Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests.vbproj @@ -4,7 +4,8 @@ Library Off - $(NetRoslyn);net472 + + $(NetVSShared);net472 From f060a3f3c08ed0752a94d75972d5477927a003ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?= Date: Sat, 25 Jan 2025 08:40:29 -0800 Subject: [PATCH 71/76] Remove accidentally added files (#76924) --- .../Microsoft.CodeAnalysis.CSharp.txt | 6243 ------------- .../Baselines/Microsoft.CodeAnalysis.txt | 4333 --------- .../System.Collections.Immutable.txt | 783 -- .../Baselines/System.Collections.txt | 431 - .../Baselines/System.Linq.txt | 231 - .../Baselines/System.Runtime.txt | 7717 ----------------- 6 files changed, 19738 deletions(-) delete mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt delete mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt delete mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt delete mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt delete mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt delete mode 100644 src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt deleted file mode 100644 index c8a0bee214e00..0000000000000 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.CSharp.txt +++ /dev/null @@ -1,6243 +0,0 @@ -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp1 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp10 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp11 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp2 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp3 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp4 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp5 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp6 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_1 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_2 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_3 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp8 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp9 -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.Default -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.LatestMajor -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.Preview -F:Microsoft.CodeAnalysis.CSharp.LanguageVersion.value__ -F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.Parameter -F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.ParameterReference -F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameter -F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameterReference -F:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.value__ -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AbstractKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AccessorList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAccessorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddressOfExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AliasKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AliasQualifiedName -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AllowsConstraintClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AllowsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandAmpersandToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AmpersandToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AndPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnnotationsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousMethodExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousObjectCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AnonymousObjectMemberDeclarator -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgListExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgListKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Argument -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArgumentList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayInitializerExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayRankSpecifier -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrayType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ArrowExpressionClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AscendingKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AscendingOrdering -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AssemblyKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsteriskEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsteriskToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AsyncKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Attribute -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeArgument -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeArgumentList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AttributeTargetSpecifier -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AwaitExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.AwaitKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BackslashToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BadDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BadToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarBarToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BarToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseConstructorInitializer -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BaseList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseAndExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseNotExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BitwiseOrExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Block -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BoolKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BracketedArgumentList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BracketedParameterList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BreakKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.BreakStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ByKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ByteKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaretEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaretToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaseKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CasePatternSwitchLabel -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CaseSwitchLabel -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CastExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchFilterClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CatchKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharacterLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharacterLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CharKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CheckedStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ChecksumKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassConstraint -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseBraceToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseBracketToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CloseParenToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CoalesceAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CoalesceExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CollectionExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CollectionInitializerExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ColonColonToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ColonToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CommaToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CompilationUnit -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ComplexElementInitializerExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConditionalAccessExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConditionalExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConflictMarkerTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstantPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstructorConstraint -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstructorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ContinueKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ContinueStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConversionOperatorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConversionOperatorMemberCref -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefBracketedParameterList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefParameter -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.CrefParameterList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DecimalKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DeclarationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DeclarationPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultConstraint -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefaultSwitchLabel -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DelegateDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DelegateKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DescendingKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DescendingOrdering -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DestructorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DisabledTextTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DisableKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DiscardDesignation -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DiscardPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DocumentationCommentExteriorTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DollarToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DotDotToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DotToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoubleKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.DoubleQuoteToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElementAccessExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElementBindingExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElifDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElifKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ElseKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EmptyStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnableKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndIfDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndIfKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfDirectiveToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfDocumentationCommentToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfFileToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndOfLineTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndRegionDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EndRegionKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EnumMemberDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsGreaterThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsValueClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ErrorDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ErrorKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventFieldDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.EventKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclusiveOrAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclusiveOrExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExplicitInterfaceSpecifier -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExplicitKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionColon -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionElement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExternAliasDirective -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExternKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FalseKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FalseLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FieldKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileScopedNamespaceDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FinallyClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FinallyKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FixedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FixedStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FloatKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForEachVariableStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ForStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FromClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FromKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerCallingConvention -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameter -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameterList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConvention -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConventionList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GenericName -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetAccessorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GlobalKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GlobalStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoCaseStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoDefaultStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GotoStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanGreaterThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanGreaterThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanOrEqualExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GroupClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.GroupKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.HashToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.HiddenKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierName -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IfStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitArrayCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitElementAccess -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitObjectCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ImplicitStackAllocArrayCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IncompleteMember -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexerDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexerMemberCref -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IndexExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InitAccessorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InitKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedMultiLineRawStringStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedRawStringEndToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedSingleLineRawStringStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringEndToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringText -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringTextToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedStringToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedVerbatimStringStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Interpolation -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolationAlignmentClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolationFormatClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IntKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IntoKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.InvocationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.IsPatternExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinIntoClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.JoinKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LabeledStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LeftShiftAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LeftShiftExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanLessThanEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanLessThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanOrEqualExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanSlashToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LetClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LetKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectivePosition -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineSpanDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.List -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ListPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LoadDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LoadKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LocalDeclarationStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LocalFunctionStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LockKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LockStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalAndExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalNotExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalOrExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.LongKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MakeRefExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MakeRefKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ManagedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MemberBindingExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MethodDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MethodKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusGreaterThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusMinusToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MinusToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuleKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuloAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ModuloExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineCommentTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineDocumentationCommentTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineRawStringLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameColon -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameEquals -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameMemberCref -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NameOfKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NamespaceDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NamespaceKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NewKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.None -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotEqualsExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullableType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NullLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectInitializerExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ObjectKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedArraySizeExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedArraySizeExpressionToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedTypeArgument -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OmittedTypeArgumentToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OnKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenBraceToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenBracketToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OpenParenToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OperatorMemberCref -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrderByClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrderByKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OrPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OutKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.OverrideKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Parameter -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParameterList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParamKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParamsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedLambdaExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ParenthesizedVariableDesignation -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PartialKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PercentEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PercentToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusPlusToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerIndirectionExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerMemberAccessExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PointerType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PositionalPatternClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostDecrementExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostIncrementExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaChecksumDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PragmaWarningDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreDecrementExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PredefinedType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreIncrementExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PreprocessingMessageTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrimaryConstructorBaseType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrivateKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PropertyPatternClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.PublicKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QualifiedCref -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QualifiedName -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryBody -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryContinuation -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QueryExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionQuestionEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionQuestionToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.QuestionToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RangeExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RazorContentToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReadOnlyKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordStructDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecursivePattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReferenceDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReferenceKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefStructConstraint -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefTypeExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefTypeKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefValueExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RefValueKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RegionDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RegionKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RelationalPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveAccessorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RequiredKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RestoreKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReturnKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ReturnStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RightShiftAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.RightShiftExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SByteKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ScopedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ScopedType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SealedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SelectClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SelectKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SemicolonToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetAccessorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ShebangDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ShortKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleBaseType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleLambdaExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleMemberAccessExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineCommentTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineDocumentationCommentTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineRawStringLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleQuoteToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleVariableDesignation -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SizeOfExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SizeOfKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SkippedTokensTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashEqualsToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashGreaterThanToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlashToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlicePattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SpreadElement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StackAllocArrayCreationExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StackAllocKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StaticKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StringLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructConstraint -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Subpattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SuppressNullableWarningExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchExpressionArm -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchSection -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.SwitchStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisConstructorInitializer -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThisKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ThrowStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TildeToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TrueKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TrueLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TryKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TryStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleElement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TupleType -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeArgumentList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeConstraint -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeCref -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeOfExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeOfKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameter -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameterConstraintClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeParameterList -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypePattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.TypeVarKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UIntKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.ULongKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryMinusExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryPlusExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UncheckedStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UndefDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UndefKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnderscoreToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnknownAccessorDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnmanagedKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsafeKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsafeStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsignedRightShiftAssignmentExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnsignedRightShiftExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UShortKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingDirective -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8MultiLineRawStringLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8SingleLineRawStringLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8StringLiteralExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.Utf8StringLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.value__ -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VariableDeclaration -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VariableDeclarator -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VarKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VarPattern -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VirtualKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VoidKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.VolatileKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningDirectiveTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WarningsKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhenClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhenKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhereClause -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhereKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhileKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhileStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WhitespaceTrivia -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithInitializerExpression -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.WithKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataEndToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataSection -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCDataStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlComment -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCommentEndToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCommentStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlCrefAttribute -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElementEndTag -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlElementStartTag -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlEmptyElement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlEntityLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlName -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlNameAttribute -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlPrefix -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstruction -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstructionEndToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlProcessingInstructionStartToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlText -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextAttribute -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextLiteralNewLineToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.XmlTextLiteralToken -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldBreakStatement -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldKeyword -F:Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldReturnStatement -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo) -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_GetAwaiterMethod -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_GetResultMethod -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_IsCompletedProperty -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.get_IsDynamic -M:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetHashCode -M:Microsoft.CodeAnalysis.CSharp.Conversion.Equals(Microsoft.CodeAnalysis.CSharp.Conversion) -M:Microsoft.CodeAnalysis.CSharp.Conversion.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_ConstrainedToType -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_Exists -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsAnonymousFunction -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsBoxing -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsCollectionExpression -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsConditionalExpression -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsConstantExpression -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsDefaultLiteral -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsDynamic -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsEnumeration -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsExplicit -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsIdentity -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsImplicit -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInlineArray -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInterpolatedString -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsInterpolatedStringHandler -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsIntPtr -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsMethodGroup -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNullable -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNullLiteral -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsNumeric -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsObjectCreation -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsPointer -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsReference -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsStackAlloc -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsSwitchExpression -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsThrow -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsTupleConversion -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsTupleLiteralConversion -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsUnboxing -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_IsUserDefined -M:Microsoft.CodeAnalysis.CSharp.Conversion.get_MethodSymbol -M:Microsoft.CodeAnalysis.CSharp.Conversion.GetHashCode -M:Microsoft.CodeAnalysis.CSharp.Conversion.op_Equality(Microsoft.CodeAnalysis.CSharp.Conversion,Microsoft.CodeAnalysis.CSharp.Conversion) -M:Microsoft.CodeAnalysis.CSharp.Conversion.op_Inequality(Microsoft.CodeAnalysis.CSharp.Conversion,Microsoft.CodeAnalysis.CSharp.Conversion) -M:Microsoft.CodeAnalysis.CSharp.Conversion.ToCommonConversion -M:Microsoft.CodeAnalysis.CSharp.Conversion.ToString -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_CompilationOptions -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_CompilationOptionsCore -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_ParseOptions -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.get_ParseOptionsCore -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_Default -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_RegularFileExtension -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_Script -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.get_ScriptFileExtension -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Parse(System.Collections.Generic.IEnumerable{System.String},System.String,System.String,System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ParseConditionalCompilationSymbols(System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Diagnostic}@) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AppendDefaultVersionResource(System.IO.Stream) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Clone -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonAddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonClone -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateNativeIntegerTypeSymbol(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonCreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetEntryPoint(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetTypeByMetadataName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonRemoveAllSyntaxTrees -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonRemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithAssemblyName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithOptions(Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonWithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference},Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CreateScriptCompilation(System.String,Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference},Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions,Microsoft.CodeAnalysis.CSharp.CSharpCompilation,System.Type,System.Type) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonAssembly -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonDynamicType -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonGlobalNamespace -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonObjectType -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonOptions -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonScriptClass -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonScriptGlobalsType -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonSourceModule -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_CommonSyntaxTrees -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_DirectiveReferences -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_IsCaseSensitive -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_Language -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_LanguageVersion -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_Options -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_ReferencedAssemblyNames -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_ScriptCompilationInfo -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.get_SyntaxTrees -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDeclarationDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDirectiveReference(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetParseDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetUsedAssemblyReferences(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllReferences -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllSyntaxTrees -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(Microsoft.CodeAnalysis.MetadataReference[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.MetadataReference) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithAssemblyName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithOptions(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(Microsoft.CodeAnalysis.MetadataReference[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider,System.Boolean,Microsoft.CodeAnalysis.MetadataImportOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.Boolean,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider,System.Boolean,Microsoft.CodeAnalysis.MetadataImportOptions,Microsoft.CodeAnalysis.NullableContextOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.#ctor(Microsoft.CodeAnalysis.OutputKind,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.OptimizationLevel,System.Boolean,System.Boolean,System.String,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Nullable{System.Boolean},Microsoft.CodeAnalysis.Platform,Microsoft.CodeAnalysis.ReportDiagnostic,System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}},System.Boolean,System.Boolean,Microsoft.CodeAnalysis.XmlReferenceResolver,Microsoft.CodeAnalysis.SourceReferenceResolver,Microsoft.CodeAnalysis.MetadataReferenceResolver,Microsoft.CodeAnalysis.AssemblyIdentityComparer,Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCheckOverflow(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithConcurrentBuild(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoKeyContainer(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoKeyFile(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithDelaySign(System.Nullable{System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithDeterministic(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithFeatures(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMainTypeName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithModuleName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithOutputKind(Microsoft.CodeAnalysis.OutputKind) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithPlatform(Microsoft.CodeAnalysis.Platform) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithPublicSign(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithReportSuppressedDiagnostics(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithScriptClassName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CommonWithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.ComputeHashCode -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_AllowUnsafe -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_Language -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_NullableContextOptions -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.get_Usings -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.set_NullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAllowUnsafe(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithConcurrentBuild(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyContainer(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyFile(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDelaySign(System.Nullable{System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterministic(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMainTypeName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithModuleName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithNullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOverflowChecks(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPublicSign(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithReportSuppressedDiagnostics(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithScriptClassName(System.String) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.String[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithWarningLevel(System.Int32) -M:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) -M:Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter.get_Instance -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAliasInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAwaitExpressionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCollectionInitializerSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCompilationUnitRoot(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConstantValue(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetElementConversion(Microsoft.CodeAnalysis.Operations.ISpreadOperation) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetFirstDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInConversion(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetIndexerGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptableLocation(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptorMethod(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptsLocationAttributeSyntax(Microsoft.CodeAnalysis.CSharp.InterceptableLocation) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetLastDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetOutConversion(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetQueryClauseInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeAliasInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeConversion(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeTypeInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Insert(Microsoft.CodeAnalysis.SyntaxTokenList,System.Int32,Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsContextualKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsReservedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimStringLiteral(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SemanticModel@,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel@) -M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.VarianceKindFromToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions.Emit(Microsoft.CodeAnalysis.CSharp.CSharpCompilation,System.String,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(Microsoft.CodeAnalysis.IIncrementalGenerator[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(Microsoft.CodeAnalysis.ISourceGenerator[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ISourceGenerator},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) -M:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ISourceGenerator},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider,Microsoft.CodeAnalysis.GeneratorDriverOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.#ctor(Microsoft.CodeAnalysis.CSharp.LanguageVersion,Microsoft.CodeAnalysis.DocumentationMode,Microsoft.CodeAnalysis.SourceCodeKind,System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Default -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Features -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_Language -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_LanguageVersion -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_PreprocessorSymbolNames -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.get_SpecifiedLanguageVersion -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.GetHashCode -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.String[]) -M:Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.get_PreviousScriptCompilation -M:Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.CSharp.CSharpCompilation) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.DeserializeFrom(System.IO.Stream,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.EquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindToken(System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.get_Language -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.get_SyntaxTreeCore -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetDiagnostics -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLeadingTrivia -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLocation -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetTrailingTrivia -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertNodesInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertTokensInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.InsertTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.IsEquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Kind -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.NormalizeWhitespaceCore(System.String,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.RemoveNodesCore(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceCore``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceNodeInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceTokenInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ReplaceTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.#ctor(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.get_VisitIntoStructuredTrivia -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.Visit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList``1(Microsoft.CodeAnalysis.SyntaxList{``0}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement``1(``0) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListSeparator(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.#ctor -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CloneNodeAsRoot``1(``0) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.get_Options -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.get_OptionsCore -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetCompilationUnitRoot(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineMappings(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineVisibility(System.Int32,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRoot(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootCore(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.HasHiddenRegions -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRoot(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode@) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRootCore(Microsoft.CodeAnalysis.SyntaxNode@) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.#ctor -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.Visit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.#ctor -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.Visit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAllowsConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCollectionExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.#ctor(Microsoft.CodeAnalysis.SyntaxWalkerDepth) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.get_Depth -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitLeadingTrivia(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrailingTrivia(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Conversion -M:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Method -M:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.get_Nested -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo) -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_CurrentConversion -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_CurrentProperty -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_DisposeMethod -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_ElementConversion -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_ElementType -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_GetEnumeratorMethod -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_IsAsynchronous -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_MoveNextMethod -M:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.GetHashCode -M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.get_Data -M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.get_Version -M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetDisplayLocation -M:Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetHashCode -M:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.MapSpecifiedToEffectiveVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion) -M:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.ToDisplayString(Microsoft.CodeAnalysis.CSharp.LanguageVersion) -M:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.TryParse(System.String,Microsoft.CodeAnalysis.CSharp.LanguageVersion@) -M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(Microsoft.CodeAnalysis.CSharp.QueryClauseInfo) -M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.get_CastInfo -M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.get_OperationInfo -M:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.GetHashCode -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(System.Char,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatPrimitive(System.Object,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableAnnotation,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.AddAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_Accessors -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithAccessors(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_Alias -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_ColonColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithColonColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.AddConstraints(Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.get_AllowsKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.get_Constraints -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.WithAllowsKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_AsyncKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_AsyncKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_DelegateKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.AddInitializers(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_Initializers -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.get_NameEquals -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_Arguments -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_NameColon -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_RefKindKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.get_RefOrOutKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.AddTypeRankSpecifiers(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.AddSizes(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_Rank -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.get_Sizes -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithSizes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.AddRankSpecifiers(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.get_ElementType -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.get_RankSpecifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithRankSpecifiers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.get_ArrowToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_Left -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.get_Right -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_Arguments -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_NameColon -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.get_NameEquals -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_Attributes -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.get_Target -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithAttributes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithTarget(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.get_AwaitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.get_Arguments -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.get_Token -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.AddTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.get_Types -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithTypes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Externs -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_NamespaceKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.get_Usings -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_AccessorList -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_BaseList -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_Left -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.get_Right -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_Left -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.get_Right -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.get_Statements -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_Arguments -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.get_BranchTaken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_BreakKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.get_WhenClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.get_Value -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_CatchKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.get_Filter -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithCatchKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithFilter(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_FilterExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.get_WhenKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithFilterExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_BaseList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.get_ClassOrStructKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.get_QuestionToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.AddElements(Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_Elements -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_AwaitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_ForEachKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_InKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_EndOfFileToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Externs -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.get_Usings -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetLoadDirectives -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetReferenceDirectives -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithEndOfFileToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.get_WhenNotNull -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithWhenNotNull(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.get_ConditionValue -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_QuestionToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_WhenFalse -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.get_WhenTrue -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenFalse(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenTrue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.get_ThisOrBaseKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithThisOrBaseKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_ContinueKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithContinueKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_CheckedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ImplicitOrExplicitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_OperatorKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_CheckedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_ImplicitOrExplicitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_OperatorKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_ReadOnlyKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_RefKindKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_RefOrOutKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.get_Designation -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.get_Designation -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.get_DefaultKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.WithDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_DefineKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithDefineKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Arity -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_DelegateKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_ReturnType -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.get_TildeToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithTildeToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_DirectiveNameToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetNextDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetPreviousDirective(System.Func{Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetRelatedDirectives -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.get_UnderscoreToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.get_UnderscoreToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.AddContent(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.get_Content -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.get_EndOfComment -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithEndOfComment(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_DoKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.get_WhileKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithDoKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_BranchTaken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_ConditionValue -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_ElifKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithConditionValue(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithElifKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.get_ElseKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_BranchTaken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_ElseKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_EndIfKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_EndRegionKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_BaseList -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_EnumKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithEnumKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_EqualsValue -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithEqualsValue(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.get_Value -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_ErrorKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithErrorKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_AccessorList -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_EventKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_EventKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.get_DotToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_AllowsAnyExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_AliasKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_ExternKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithAliasKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithExternKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Externs -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_NamespaceKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.get_Usings -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.get_FinallyKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithFinallyKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_FixedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithFixedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_AwaitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_ForEachKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_InKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_AwaitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_ForEachKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_InKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.get_Variable -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithVariable(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddIncrementors(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddInitializers(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_FirstSemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_ForKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Incrementors -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Initializers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_SecondSemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithFirstSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithForKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithIncrementors(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithSecondSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_FromKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_InKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithFromKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.get_ManagedOrUnmanagedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.get_UnmanagedCallingConventionList -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedOrUnmanagedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_GreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_LessThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_AsteriskToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_CallingConvention -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_DelegateKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.AddCallingConventions(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_CallingConventions -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.AddTypeArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_IsUnboundGenericName -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.get_TypeArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_CaseOrDefaultKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_GotoKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithCaseOrDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithGotoKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_ByExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_ByKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_GroupExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.get_GroupKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_BranchTaken -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_ConditionValue -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_IfKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithBranchTaken(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithConditionValue(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Else -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_IfKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithElse(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddCommas(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_Commas -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCommas(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.get_StackAllocKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_AccessorList -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Semicolon -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_ThisKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.get_ThisKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.AddExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_Expressions -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithExpressions(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_BaseList -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.AddContents(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_Contents -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_StringEndToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.get_StringStartToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithContents(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringEndToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringStartToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.get_TextToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.WithTextToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.get_CommaToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.get_Value -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.get_FormatStringToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithFormatStringToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_AlignmentClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_FormatClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_IsKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithIsKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_EqualsKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_InExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_InKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Into -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_JoinKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_LeftExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_OnKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_RightExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithEqualsKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInto(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithJoinKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithLeftExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithOnKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithRightExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.get_IntoKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.get_ArrowToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.get_LetKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithLetKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_Character -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_CommaToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_Line -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCharacter(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_File -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_Line -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.get_LineKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.get_File -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.get_LineKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_CharacterOffset -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_End -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_File -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_LineKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_MinusToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.get_Start -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithCharacterOffset(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEnd(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithMinusToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithStart(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.AddPatterns(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_CloseBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_Designation -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_OpenBracketToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.get_Patterns -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithPatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.get_Token -M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_File -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.get_LoadKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithLoadKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddDeclarationVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_AwaitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_IsConst -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.get_UsingKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_ReturnType -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_LockKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithLockKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Arity -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_ReturnType -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddExterns(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddUsings(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Externs -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_NamespaceKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.get_Usings -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax.get_Arity -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_NullableKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_SettingToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.get_TargetToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithNullableKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithSettingToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithTargetToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.get_ElementType -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.get_QuestionToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_NewKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.get_OmittedArraySizeExpressionToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.WithOmittedArraySizeExpressionToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.get_OmittedTypeArgumentToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.WithOmittedTypeArgumentToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_CheckedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_OperatorKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_ReturnType -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.AddParametersParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_CheckedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_OperatorKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithCheckedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.AddOrderings(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.get_OrderByKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.get_Orderings -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderByKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderings(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.get_AscendingOrDescendingKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithAscendingOrDescendingKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Default -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ArrowToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_AsyncKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.get_ReturnType -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.AddVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.get_Variables -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.get_AsteriskToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.get_ElementType -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.AddSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.get_Subpatterns -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.get_Operand -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_Bytes -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_ChecksumKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_File -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_Guid -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.get_PragmaKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithBytes(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithChecksumKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithGuid(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.AddErrorCodes(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_DisableOrRestoreKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_ErrorCodes -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_PragmaKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.get_WarningKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithDisableOrRestoreKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithErrorCodes(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.get_Operand -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAccessorListAccessors(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_AccessorList -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_ExplicitInterfaceSpecifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Semicolon -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.AddSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.get_Subpatterns -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_Container -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_DotToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.get_Member -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithContainer(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithMember(Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_DotToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_Left -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.get_Right -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.AddClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_Clauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_Continuation -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.get_SelectOrGroup -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithSelectOrGroup(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.AddBodyClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.get_IntoKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.AddBodyClauses(Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.get_Body -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.get_FromClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_LeftOperand -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.get_RightOperand -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithLeftOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithRightOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_BaseList -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ClassOrStructKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPositionalPatternClauseSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPropertyPatternClauseSubpatterns(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_Designation -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_PositionalPatternClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_PropertyPatternClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_File -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.get_ReferenceKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithReferenceKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.get_RefKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.get_RefKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.get_StructKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax.WithStructKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_ReadOnlyKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_RefKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Comma -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithComma(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.get_RegionKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_ReturnKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithReturnKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.get_ScopedKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.WithScopedKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.get_SelectKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithSelectKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_ExclamationToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithExclamationToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_ArrowToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_AsyncKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_ExpressionBody -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.get_Parameter -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.AddTokens(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.get_Tokens -M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.WithTokens(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.get_DotDotToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithDotDotToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_StackAllocKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_BaseList -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_Modifiers -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax.get_ParentTrivia -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_ExpressionColon -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_NameColon -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_EqualsGreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.get_WhenClause -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithEqualsGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.AddArms(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_Arms -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_GoverningExpression -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.get_SwitchKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithArms(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithGoverningExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddLabels(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.get_Labels -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.get_Statements -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithLabels(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddSections(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_CloseBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_OpenBraceToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_Sections -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.get_SwitchKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSections(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.get_Token -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.get_ThrowKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.get_ThrowKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddCatches(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Catches -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_Finally -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.get_TryKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithCatches(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithFinally(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithTryKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_Arguments -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.AddElements(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_Elements -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.AddArguments(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_Arguments -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_GreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.get_LessThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddBaseListTypes(Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddConstraintClauses(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddMembers(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddModifiers(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddTypeParameterListParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Arity -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_ConstraintClauses -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_Members -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_ParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.get_TypeParameterList -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_Keyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.AddConstraints(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_Constraints -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.get_WhereKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.AddParameters(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_GreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_LessThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.get_Parameters -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.get_VarianceKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithVarianceKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNint -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNotNull -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsNuint -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsUnmanaged -M:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.get_IsVar -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.get_OperatorToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.get_Pattern -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.get_UndefKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithUndefKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockStatements(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_Block -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.get_UnsafeKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_Alias -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_GlobalKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_NamespaceOrType -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_StaticKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_UnsafeKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.get_UsingKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithGlobalKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithNamespaceOrType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithStaticKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_AwaitKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Declaration -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.get_UsingKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.AddVariables(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.get_Type -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.get_Variables -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.AddArgumentListArguments(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_ArgumentList -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.get_Designation -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.get_VarKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithVarKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_EndOfDirectiveToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_HashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_IsActive -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.get_WarningKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithIsActive(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.get_WhenKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.get_WhereKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_CloseParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_Condition -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_OpenParenToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_Statement -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.get_WhileKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.AddInitializerExpressions(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_Initializer -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.get_WithKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithWithKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_EndQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.get_StartQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_EndCDataToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_StartCDataToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.get_TextTokens -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithEndCDataToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithStartCDataToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_LessThanExclamationMinusMinusToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_MinusMinusGreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.get_TextTokens -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithLessThanExclamationMinusMinusToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithMinusMinusGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_Cref -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_EndQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.get_StartQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_GreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_LessThanSlashToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithLessThanSlashToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_Attributes -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_GreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_LessThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddContent(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddStartTagAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_Content -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_EndTag -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.get_StartTag -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.AddAttributes(Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_Attributes -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_LessThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.get_SlashGreaterThanToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithSlashGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_EndQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_Identifier -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.get_StartQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.get_LocalName -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.get_Prefix -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithLocalName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.get_ColonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.get_Prefix -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithPrefix(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_EndProcessingInstructionToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_StartProcessingInstructionToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.get_TextTokens -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithEndProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithStartProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_EndQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_EqualsToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_Name -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_StartQuoteToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.get_TextTokens -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.AddTextTokens(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.get_TextTokens -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept``1(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor{``0}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AddAttributeLists(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_AttributeLists -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_Expression -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_ReturnOrBreakKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_SemicolonToken -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.get_YieldKeyword -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithReturnOrBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithYieldKeyword(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxToken,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxToken,System.String,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.ToSyntaxTriviaList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AllowsConstraintClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AllowsConstraintClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.SyntaxList{``0},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.SyntaxList{``0},System.Func{Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.Boolean}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadToken(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CollectionExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CollectionExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Comment(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CreateTokenParser(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DisabledText(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentExterior(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticEndOfLine(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticWhitespace(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_CarriageReturn -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_CarriageReturnLineFeed -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticCarriageReturn -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticCarriageReturnLineFeed -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticLineFeed -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticMarker -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticSpace -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_ElasticTab -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_LineFeed -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_Space -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.get_Tab -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetNonGenericExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetStandaloneExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationAlignmentClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsCompleteSubmission(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List``1 -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List``1(System.Collections.Generic.IEnumerable{``0}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Char,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Decimal,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Double,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Int32,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Int64,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.Single,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.UInt32,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.UInt64,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Char) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Decimal) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Double) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Int32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Int64) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.Single) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Char) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Decimal) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Double) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Int32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Int64) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.Single) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.UInt32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.String,System.UInt64) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.UInt32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(System.UInt64) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(Microsoft.CodeAnalysis.SyntaxNodeOrToken[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseAttributeArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedArgumentList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedParameterList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseCompilationUnit(System.String,System.Int32,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseExpression(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseLeadingTrivia(System.String,System.Int32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseMemberDeclaration(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseName(System.String,System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseParameterList(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseStatement(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseToken(System.String,System.Int32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTokens(System.String,System.Int32,System.Int32,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTrailingTrivia(System.String,System.Int32) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(System.String,System.Int32,Microsoft.CodeAnalysis.ParseOptions,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(System.String,System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax},Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PredefinedType(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PreprocessingMessage(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefStructConstraint -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefStructConstraint(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RelationalPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ScopedType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1 -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{``0}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList``1(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonList``1(``0) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonSeparatedList``1(``0) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingleVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SpreadElement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax},Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Trivia(Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax},Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEntity(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,System.String,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNewLine(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNullKeywordElement -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(System.String,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(System.String,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamRefElement(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPreliminaryElement -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(System.Uri,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(System.String,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(System.String,System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(Microsoft.CodeAnalysis.SyntaxTriviaList,System.String,System.String,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement(System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[]) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax}) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax},Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.get_EqualityComparer -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAccessorDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBaseTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetCheckStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKind(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKinds -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKind(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKinds -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetOperatorKind(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKind(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKinds -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPunctuationKinds -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetReservedKeywordKinds -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetSwitchLabelKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.Accessibility) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessibilityModifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclarationKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAliasQualifier(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyOverloadableOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeName(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsCheckedOperator(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsFixedStatementExpression(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsGlobalMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierPartCharacter(System.Char) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierStartCharacter(System.Char) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIndexed(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInNamespaceOrTypeContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInTypeOnlyContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInvoked(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsKeywordKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLambdaBody(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLanguagePunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsName(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamedArgumentName(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceAliasQualifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNewLine(System.Char) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableBinaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableUnaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPostfixUnaryExpressionToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPredefinedType(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrefixUnaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorDirective(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPreprocessorPunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuationOrKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsQueryContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedTupleElementName(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeParameterVarianceKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeSyntax(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsUnaryOperatorDeclarationToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsValidIdentifier(System.String) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsWhitespace(System.Char) -M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.TryGetInferredMemberName(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Dispose -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseLeadingTrivia -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseNextToken -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ParseTrailingTrivia -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.ResetTo(Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result) -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result.get_ContextualKind -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result.get_Token -M:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.SkipForwardTo(System.Int32) -M:Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions.ToCSharpString(Microsoft.CodeAnalysis.TypedConstant) -M:Microsoft.CodeAnalysis.CSharpExtensions.Any(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.Any(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.Any``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.Any``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.ContainsDirective(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf``1(Microsoft.CodeAnalysis.SeparatedSyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IndexOf``1(Microsoft.CodeAnalysis.SyntaxList{``0},Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -M:Microsoft.CodeAnalysis.CSharpExtensions.IsKind(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.CSharp.SyntaxKind) -T:Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo -T:Microsoft.CodeAnalysis.CSharp.Conversion -T:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments -T:Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser -T:Microsoft.CodeAnalysis.CSharp.CSharpCompilation -T:Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions -T:Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter -T:Microsoft.CodeAnalysis.CSharp.CSharpExtensions -T:Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions -T:Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver -T:Microsoft.CodeAnalysis.CSharp.CSharpParseOptions -T:Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo -T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode -T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter -T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree -T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor -T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor`1 -T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker -T:Microsoft.CodeAnalysis.CSharp.DeconstructionInfo -T:Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo -T:Microsoft.CodeAnalysis.CSharp.InterceptableLocation -T:Microsoft.CodeAnalysis.CSharp.LanguageVersion -T:Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts -T:Microsoft.CodeAnalysis.CSharp.QueryClauseInfo -T:Microsoft.CodeAnalysis.CSharp.SymbolDisplay -T:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AllowsConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InstanceExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RefStructConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax -T:Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax -T:Microsoft.CodeAnalysis.CSharp.SyntaxExtensions -T:Microsoft.CodeAnalysis.CSharp.SyntaxFactory -T:Microsoft.CodeAnalysis.CSharp.SyntaxFacts -T:Microsoft.CodeAnalysis.CSharp.SyntaxKind -T:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser -T:Microsoft.CodeAnalysis.CSharp.SyntaxTokenParser.Result -T:Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions -T:Microsoft.CodeAnalysis.CSharpExtensions \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt deleted file mode 100644 index 4cf6b5e5b832f..0000000000000 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/Microsoft.CodeAnalysis.txt +++ /dev/null @@ -1,4333 +0,0 @@ -F:Microsoft.CodeAnalysis.Accessibility.Friend -F:Microsoft.CodeAnalysis.Accessibility.Internal -F:Microsoft.CodeAnalysis.Accessibility.NotApplicable -F:Microsoft.CodeAnalysis.Accessibility.Private -F:Microsoft.CodeAnalysis.Accessibility.Protected -F:Microsoft.CodeAnalysis.Accessibility.ProtectedAndFriend -F:Microsoft.CodeAnalysis.Accessibility.ProtectedAndInternal -F:Microsoft.CodeAnalysis.Accessibility.ProtectedOrFriend -F:Microsoft.CodeAnalysis.Accessibility.ProtectedOrInternal -F:Microsoft.CodeAnalysis.Accessibility.Public -F:Microsoft.CodeAnalysis.Accessibility.value__ -F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.Equivalent -F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.EquivalentIgnoringVersion -F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.NotEquivalent -F:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult.value__ -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.ContentType -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Culture -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Name -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKey -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKeyOrToken -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.PublicKeyToken -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Retargetability -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Unknown -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.value__ -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.Version -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionBuild -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionMajor -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionMinor -F:Microsoft.CodeAnalysis.AssemblyIdentityParts.VersionRevision -F:Microsoft.CodeAnalysis.CandidateReason.Ambiguous -F:Microsoft.CodeAnalysis.CandidateReason.Inaccessible -F:Microsoft.CodeAnalysis.CandidateReason.LateBound -F:Microsoft.CodeAnalysis.CandidateReason.MemberGroup -F:Microsoft.CodeAnalysis.CandidateReason.None -F:Microsoft.CodeAnalysis.CandidateReason.NotAnAttributeType -F:Microsoft.CodeAnalysis.CandidateReason.NotAnEvent -F:Microsoft.CodeAnalysis.CandidateReason.NotATypeOrNamespace -F:Microsoft.CodeAnalysis.CandidateReason.NotAValue -F:Microsoft.CodeAnalysis.CandidateReason.NotAVariable -F:Microsoft.CodeAnalysis.CandidateReason.NotAWithEventsMember -F:Microsoft.CodeAnalysis.CandidateReason.NotCreatable -F:Microsoft.CodeAnalysis.CandidateReason.NotInvocable -F:Microsoft.CodeAnalysis.CandidateReason.NotReferencable -F:Microsoft.CodeAnalysis.CandidateReason.OverloadResolutionFailure -F:Microsoft.CodeAnalysis.CandidateReason.StaticInstanceMismatch -F:Microsoft.CodeAnalysis.CandidateReason.value__ -F:Microsoft.CodeAnalysis.CandidateReason.WrongArity -F:Microsoft.CodeAnalysis.Compilation._features -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.None -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesFramework -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesNewerCompiler -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer -F:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode.value__ -F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.Analyze -F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.None -F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.ReportDiagnostics -F:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags.value__ -F:Microsoft.CodeAnalysis.DiagnosticSeverity.Error -F:Microsoft.CodeAnalysis.DiagnosticSeverity.Hidden -F:Microsoft.CodeAnalysis.DiagnosticSeverity.Info -F:Microsoft.CodeAnalysis.DiagnosticSeverity.value__ -F:Microsoft.CodeAnalysis.DiagnosticSeverity.Warning -F:Microsoft.CodeAnalysis.DocumentationMode.Diagnose -F:Microsoft.CodeAnalysis.DocumentationMode.None -F:Microsoft.CodeAnalysis.DocumentationMode.Parse -F:Microsoft.CodeAnalysis.DocumentationMode.value__ -F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.Embedded -F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.Pdb -F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.PortablePdb -F:Microsoft.CodeAnalysis.Emit.DebugInformationFormat.value__ -F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.ModuleCancellation -F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.None -F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.StackOverflowProbing -F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.TestCoverage -F:Microsoft.CodeAnalysis.Emit.InstrumentationKind.value__ -F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Delete -F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Insert -F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.None -F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Replace -F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.Update -F:Microsoft.CodeAnalysis.Emit.SemanticEditKind.value__ -F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Block -F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Entry -F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.Exit -F:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind.value__ -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Error -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.None -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.ProgramTermination -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Regular -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Rethrow -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Return -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.StructuredExceptionHandling -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.Throw -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics.value__ -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.None -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.value__ -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.WhenFalse -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind.WhenTrue -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Catch -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.ErroneousBody -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Filter -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.FilterAndHandler -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Finally -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.LocalLifetime -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Root -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.StaticLocalInitializer -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.Try -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.TryAndCatch -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.TryAndFinally -F:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind.value__ -F:Microsoft.CodeAnalysis.GeneratedKind.MarkedGenerated -F:Microsoft.CodeAnalysis.GeneratedKind.NotGenerated -F:Microsoft.CodeAnalysis.GeneratedKind.Unknown -F:Microsoft.CodeAnalysis.GeneratedKind.value__ -F:Microsoft.CodeAnalysis.GeneratorDriverOptions.DisabledOutputs -F:Microsoft.CodeAnalysis.GeneratorDriverOptions.TrackIncrementalGeneratorSteps -F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Implementation -F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.None -F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.PostInit -F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.Source -F:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.value__ -F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Cached -F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Modified -F:Microsoft.CodeAnalysis.IncrementalStepRunReason.New -F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Removed -F:Microsoft.CodeAnalysis.IncrementalStepRunReason.Unchanged -F:Microsoft.CodeAnalysis.IncrementalStepRunReason.value__ -F:Microsoft.CodeAnalysis.LanguageNames.CSharp -F:Microsoft.CodeAnalysis.LanguageNames.FSharp -F:Microsoft.CodeAnalysis.LanguageNames.VisualBasic -F:Microsoft.CodeAnalysis.LineVisibility.BeforeFirstLineDirective -F:Microsoft.CodeAnalysis.LineVisibility.Hidden -F:Microsoft.CodeAnalysis.LineVisibility.value__ -F:Microsoft.CodeAnalysis.LineVisibility.Visible -F:Microsoft.CodeAnalysis.LocationKind.ExternalFile -F:Microsoft.CodeAnalysis.LocationKind.MetadataFile -F:Microsoft.CodeAnalysis.LocationKind.None -F:Microsoft.CodeAnalysis.LocationKind.SourceFile -F:Microsoft.CodeAnalysis.LocationKind.value__ -F:Microsoft.CodeAnalysis.LocationKind.XmlFile -F:Microsoft.CodeAnalysis.MetadataImageKind.Assembly -F:Microsoft.CodeAnalysis.MetadataImageKind.Module -F:Microsoft.CodeAnalysis.MetadataImageKind.value__ -F:Microsoft.CodeAnalysis.MetadataImportOptions.All -F:Microsoft.CodeAnalysis.MetadataImportOptions.Internal -F:Microsoft.CodeAnalysis.MetadataImportOptions.Public -F:Microsoft.CodeAnalysis.MetadataImportOptions.value__ -F:Microsoft.CodeAnalysis.MethodKind.AnonymousFunction -F:Microsoft.CodeAnalysis.MethodKind.BuiltinOperator -F:Microsoft.CodeAnalysis.MethodKind.Constructor -F:Microsoft.CodeAnalysis.MethodKind.Conversion -F:Microsoft.CodeAnalysis.MethodKind.DeclareMethod -F:Microsoft.CodeAnalysis.MethodKind.DelegateInvoke -F:Microsoft.CodeAnalysis.MethodKind.Destructor -F:Microsoft.CodeAnalysis.MethodKind.EventAdd -F:Microsoft.CodeAnalysis.MethodKind.EventRaise -F:Microsoft.CodeAnalysis.MethodKind.EventRemove -F:Microsoft.CodeAnalysis.MethodKind.ExplicitInterfaceImplementation -F:Microsoft.CodeAnalysis.MethodKind.FunctionPointerSignature -F:Microsoft.CodeAnalysis.MethodKind.LambdaMethod -F:Microsoft.CodeAnalysis.MethodKind.LocalFunction -F:Microsoft.CodeAnalysis.MethodKind.Ordinary -F:Microsoft.CodeAnalysis.MethodKind.PropertyGet -F:Microsoft.CodeAnalysis.MethodKind.PropertySet -F:Microsoft.CodeAnalysis.MethodKind.ReducedExtension -F:Microsoft.CodeAnalysis.MethodKind.SharedConstructor -F:Microsoft.CodeAnalysis.MethodKind.StaticConstructor -F:Microsoft.CodeAnalysis.MethodKind.UserDefinedOperator -F:Microsoft.CodeAnalysis.MethodKind.value__ -F:Microsoft.CodeAnalysis.NamespaceKind.Assembly -F:Microsoft.CodeAnalysis.NamespaceKind.Compilation -F:Microsoft.CodeAnalysis.NamespaceKind.Module -F:Microsoft.CodeAnalysis.NamespaceKind.value__ -F:Microsoft.CodeAnalysis.NullableAnnotation.Annotated -F:Microsoft.CodeAnalysis.NullableAnnotation.None -F:Microsoft.CodeAnalysis.NullableAnnotation.NotAnnotated -F:Microsoft.CodeAnalysis.NullableAnnotation.value__ -F:Microsoft.CodeAnalysis.NullableContext.AnnotationsContextInherited -F:Microsoft.CodeAnalysis.NullableContext.AnnotationsEnabled -F:Microsoft.CodeAnalysis.NullableContext.ContextInherited -F:Microsoft.CodeAnalysis.NullableContext.Disabled -F:Microsoft.CodeAnalysis.NullableContext.Enabled -F:Microsoft.CodeAnalysis.NullableContext.value__ -F:Microsoft.CodeAnalysis.NullableContext.WarningsContextInherited -F:Microsoft.CodeAnalysis.NullableContext.WarningsEnabled -F:Microsoft.CodeAnalysis.NullableContextOptions.Annotations -F:Microsoft.CodeAnalysis.NullableContextOptions.Disable -F:Microsoft.CodeAnalysis.NullableContextOptions.Enable -F:Microsoft.CodeAnalysis.NullableContextOptions.value__ -F:Microsoft.CodeAnalysis.NullableContextOptions.Warnings -F:Microsoft.CodeAnalysis.NullableFlowState.MaybeNull -F:Microsoft.CodeAnalysis.NullableFlowState.None -F:Microsoft.CodeAnalysis.NullableFlowState.NotNull -F:Microsoft.CodeAnalysis.NullableFlowState.value__ -F:Microsoft.CodeAnalysis.OperationKind.AddressOf -F:Microsoft.CodeAnalysis.OperationKind.AnonymousFunction -F:Microsoft.CodeAnalysis.OperationKind.AnonymousObjectCreation -F:Microsoft.CodeAnalysis.OperationKind.Argument -F:Microsoft.CodeAnalysis.OperationKind.ArrayCreation -F:Microsoft.CodeAnalysis.OperationKind.ArrayElementReference -F:Microsoft.CodeAnalysis.OperationKind.ArrayInitializer -F:Microsoft.CodeAnalysis.OperationKind.Attribute -F:Microsoft.CodeAnalysis.OperationKind.Await -F:Microsoft.CodeAnalysis.OperationKind.Binary -F:Microsoft.CodeAnalysis.OperationKind.BinaryOperator -F:Microsoft.CodeAnalysis.OperationKind.BinaryPattern -F:Microsoft.CodeAnalysis.OperationKind.Block -F:Microsoft.CodeAnalysis.OperationKind.Branch -F:Microsoft.CodeAnalysis.OperationKind.CaseClause -F:Microsoft.CodeAnalysis.OperationKind.CatchClause -F:Microsoft.CodeAnalysis.OperationKind.CaughtException -F:Microsoft.CodeAnalysis.OperationKind.Coalesce -F:Microsoft.CodeAnalysis.OperationKind.CoalesceAssignment -F:Microsoft.CodeAnalysis.OperationKind.CollectionElementInitializer -F:Microsoft.CodeAnalysis.OperationKind.CollectionExpression -F:Microsoft.CodeAnalysis.OperationKind.CompoundAssignment -F:Microsoft.CodeAnalysis.OperationKind.Conditional -F:Microsoft.CodeAnalysis.OperationKind.ConditionalAccess -F:Microsoft.CodeAnalysis.OperationKind.ConditionalAccessInstance -F:Microsoft.CodeAnalysis.OperationKind.ConstantPattern -F:Microsoft.CodeAnalysis.OperationKind.ConstructorBody -F:Microsoft.CodeAnalysis.OperationKind.ConstructorBodyOperation -F:Microsoft.CodeAnalysis.OperationKind.Conversion -F:Microsoft.CodeAnalysis.OperationKind.DeclarationExpression -F:Microsoft.CodeAnalysis.OperationKind.DeclarationPattern -F:Microsoft.CodeAnalysis.OperationKind.DeconstructionAssignment -F:Microsoft.CodeAnalysis.OperationKind.Decrement -F:Microsoft.CodeAnalysis.OperationKind.DefaultValue -F:Microsoft.CodeAnalysis.OperationKind.DelegateCreation -F:Microsoft.CodeAnalysis.OperationKind.Discard -F:Microsoft.CodeAnalysis.OperationKind.DiscardPattern -F:Microsoft.CodeAnalysis.OperationKind.DynamicIndexerAccess -F:Microsoft.CodeAnalysis.OperationKind.DynamicInvocation -F:Microsoft.CodeAnalysis.OperationKind.DynamicMemberReference -F:Microsoft.CodeAnalysis.OperationKind.DynamicObjectCreation -F:Microsoft.CodeAnalysis.OperationKind.Empty -F:Microsoft.CodeAnalysis.OperationKind.End -F:Microsoft.CodeAnalysis.OperationKind.EventAssignment -F:Microsoft.CodeAnalysis.OperationKind.EventReference -F:Microsoft.CodeAnalysis.OperationKind.ExpressionStatement -F:Microsoft.CodeAnalysis.OperationKind.FieldInitializer -F:Microsoft.CodeAnalysis.OperationKind.FieldReference -F:Microsoft.CodeAnalysis.OperationKind.FlowAnonymousFunction -F:Microsoft.CodeAnalysis.OperationKind.FlowCapture -F:Microsoft.CodeAnalysis.OperationKind.FlowCaptureReference -F:Microsoft.CodeAnalysis.OperationKind.FunctionPointerInvocation -F:Microsoft.CodeAnalysis.OperationKind.ImplicitIndexerReference -F:Microsoft.CodeAnalysis.OperationKind.Increment -F:Microsoft.CodeAnalysis.OperationKind.InlineArrayAccess -F:Microsoft.CodeAnalysis.OperationKind.InstanceReference -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedString -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAddition -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendFormatted -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendInvalid -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringAppendLiteral -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringHandlerArgumentPlaceholder -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringHandlerCreation -F:Microsoft.CodeAnalysis.OperationKind.InterpolatedStringText -F:Microsoft.CodeAnalysis.OperationKind.Interpolation -F:Microsoft.CodeAnalysis.OperationKind.Invalid -F:Microsoft.CodeAnalysis.OperationKind.Invocation -F:Microsoft.CodeAnalysis.OperationKind.IsNull -F:Microsoft.CodeAnalysis.OperationKind.IsPattern -F:Microsoft.CodeAnalysis.OperationKind.IsType -F:Microsoft.CodeAnalysis.OperationKind.Labeled -F:Microsoft.CodeAnalysis.OperationKind.ListPattern -F:Microsoft.CodeAnalysis.OperationKind.Literal -F:Microsoft.CodeAnalysis.OperationKind.LocalFunction -F:Microsoft.CodeAnalysis.OperationKind.LocalReference -F:Microsoft.CodeAnalysis.OperationKind.Lock -F:Microsoft.CodeAnalysis.OperationKind.Loop -F:Microsoft.CodeAnalysis.OperationKind.MemberInitializer -F:Microsoft.CodeAnalysis.OperationKind.MethodBody -F:Microsoft.CodeAnalysis.OperationKind.MethodBodyOperation -F:Microsoft.CodeAnalysis.OperationKind.MethodReference -F:Microsoft.CodeAnalysis.OperationKind.NameOf -F:Microsoft.CodeAnalysis.OperationKind.NegatedPattern -F:Microsoft.CodeAnalysis.OperationKind.None -F:Microsoft.CodeAnalysis.OperationKind.ObjectCreation -F:Microsoft.CodeAnalysis.OperationKind.ObjectOrCollectionInitializer -F:Microsoft.CodeAnalysis.OperationKind.OmittedArgument -F:Microsoft.CodeAnalysis.OperationKind.ParameterInitializer -F:Microsoft.CodeAnalysis.OperationKind.ParameterReference -F:Microsoft.CodeAnalysis.OperationKind.Parenthesized -F:Microsoft.CodeAnalysis.OperationKind.PropertyInitializer -F:Microsoft.CodeAnalysis.OperationKind.PropertyReference -F:Microsoft.CodeAnalysis.OperationKind.PropertySubpattern -F:Microsoft.CodeAnalysis.OperationKind.RaiseEvent -F:Microsoft.CodeAnalysis.OperationKind.Range -F:Microsoft.CodeAnalysis.OperationKind.RecursivePattern -F:Microsoft.CodeAnalysis.OperationKind.ReDim -F:Microsoft.CodeAnalysis.OperationKind.ReDimClause -F:Microsoft.CodeAnalysis.OperationKind.RelationalPattern -F:Microsoft.CodeAnalysis.OperationKind.Return -F:Microsoft.CodeAnalysis.OperationKind.SimpleAssignment -F:Microsoft.CodeAnalysis.OperationKind.SizeOf -F:Microsoft.CodeAnalysis.OperationKind.SlicePattern -F:Microsoft.CodeAnalysis.OperationKind.Spread -F:Microsoft.CodeAnalysis.OperationKind.StaticLocalInitializationSemaphore -F:Microsoft.CodeAnalysis.OperationKind.Stop -F:Microsoft.CodeAnalysis.OperationKind.Switch -F:Microsoft.CodeAnalysis.OperationKind.SwitchCase -F:Microsoft.CodeAnalysis.OperationKind.SwitchExpression -F:Microsoft.CodeAnalysis.OperationKind.SwitchExpressionArm -F:Microsoft.CodeAnalysis.OperationKind.Throw -F:Microsoft.CodeAnalysis.OperationKind.TranslatedQuery -F:Microsoft.CodeAnalysis.OperationKind.Try -F:Microsoft.CodeAnalysis.OperationKind.Tuple -F:Microsoft.CodeAnalysis.OperationKind.TupleBinary -F:Microsoft.CodeAnalysis.OperationKind.TupleBinaryOperator -F:Microsoft.CodeAnalysis.OperationKind.TypeOf -F:Microsoft.CodeAnalysis.OperationKind.TypeParameterObjectCreation -F:Microsoft.CodeAnalysis.OperationKind.TypePattern -F:Microsoft.CodeAnalysis.OperationKind.Unary -F:Microsoft.CodeAnalysis.OperationKind.UnaryOperator -F:Microsoft.CodeAnalysis.OperationKind.Using -F:Microsoft.CodeAnalysis.OperationKind.UsingDeclaration -F:Microsoft.CodeAnalysis.OperationKind.Utf8String -F:Microsoft.CodeAnalysis.OperationKind.value__ -F:Microsoft.CodeAnalysis.OperationKind.VariableDeclaration -F:Microsoft.CodeAnalysis.OperationKind.VariableDeclarationGroup -F:Microsoft.CodeAnalysis.OperationKind.VariableDeclarator -F:Microsoft.CodeAnalysis.OperationKind.VariableInitializer -F:Microsoft.CodeAnalysis.OperationKind.With -F:Microsoft.CodeAnalysis.OperationKind.YieldBreak -F:Microsoft.CodeAnalysis.OperationKind.YieldReturn -F:Microsoft.CodeAnalysis.Operations.ArgumentKind.DefaultValue -F:Microsoft.CodeAnalysis.Operations.ArgumentKind.Explicit -F:Microsoft.CodeAnalysis.Operations.ArgumentKind.None -F:Microsoft.CodeAnalysis.Operations.ArgumentKind.ParamArray -F:Microsoft.CodeAnalysis.Operations.ArgumentKind.ParamCollection -F:Microsoft.CodeAnalysis.Operations.ArgumentKind.value__ -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Add -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.And -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Concatenate -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ConditionalAnd -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ConditionalOr -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Divide -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Equals -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ExclusiveOr -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.GreaterThan -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.GreaterThanOrEqual -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.IntegerDivide -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LeftShift -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LessThan -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.LessThanOrEqual -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Like -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Multiply -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.None -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.NotEquals -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ObjectValueEquals -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.ObjectValueNotEquals -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Or -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Power -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Remainder -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.RightShift -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.Subtract -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.UnsignedRightShift -F:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.value__ -F:Microsoft.CodeAnalysis.Operations.BranchKind.Break -F:Microsoft.CodeAnalysis.Operations.BranchKind.Continue -F:Microsoft.CodeAnalysis.Operations.BranchKind.GoTo -F:Microsoft.CodeAnalysis.Operations.BranchKind.None -F:Microsoft.CodeAnalysis.Operations.BranchKind.value__ -F:Microsoft.CodeAnalysis.Operations.CaseKind.Default -F:Microsoft.CodeAnalysis.Operations.CaseKind.None -F:Microsoft.CodeAnalysis.Operations.CaseKind.Pattern -F:Microsoft.CodeAnalysis.Operations.CaseKind.Range -F:Microsoft.CodeAnalysis.Operations.CaseKind.Relational -F:Microsoft.CodeAnalysis.Operations.CaseKind.SingleValue -F:Microsoft.CodeAnalysis.Operations.CaseKind.value__ -F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.ContainingTypeInstance -F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.ImplicitReceiver -F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.InterpolatedStringHandler -F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.PatternInput -F:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind.value__ -F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.CallsiteArgument -F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.CallsiteReceiver -F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.TrailingValidityArgument -F:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind.value__ -F:Microsoft.CodeAnalysis.Operations.LoopKind.For -F:Microsoft.CodeAnalysis.Operations.LoopKind.ForEach -F:Microsoft.CodeAnalysis.Operations.LoopKind.ForTo -F:Microsoft.CodeAnalysis.Operations.LoopKind.None -F:Microsoft.CodeAnalysis.Operations.LoopKind.value__ -F:Microsoft.CodeAnalysis.Operations.LoopKind.While -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.BitwiseNegation -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.False -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Hat -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Minus -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.None -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Not -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.Plus -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.True -F:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind.value__ -F:Microsoft.CodeAnalysis.OptimizationLevel.Debug -F:Microsoft.CodeAnalysis.OptimizationLevel.Release -F:Microsoft.CodeAnalysis.OptimizationLevel.value__ -F:Microsoft.CodeAnalysis.OutputKind.ConsoleApplication -F:Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary -F:Microsoft.CodeAnalysis.OutputKind.NetModule -F:Microsoft.CodeAnalysis.OutputKind.value__ -F:Microsoft.CodeAnalysis.OutputKind.WindowsApplication -F:Microsoft.CodeAnalysis.OutputKind.WindowsRuntimeApplication -F:Microsoft.CodeAnalysis.OutputKind.WindowsRuntimeMetadata -F:Microsoft.CodeAnalysis.Platform.AnyCpu -F:Microsoft.CodeAnalysis.Platform.AnyCpu32BitPreferred -F:Microsoft.CodeAnalysis.Platform.Arm -F:Microsoft.CodeAnalysis.Platform.Arm64 -F:Microsoft.CodeAnalysis.Platform.Itanium -F:Microsoft.CodeAnalysis.Platform.value__ -F:Microsoft.CodeAnalysis.Platform.X64 -F:Microsoft.CodeAnalysis.Platform.X86 -F:Microsoft.CodeAnalysis.RefKind.In -F:Microsoft.CodeAnalysis.RefKind.None -F:Microsoft.CodeAnalysis.RefKind.Out -F:Microsoft.CodeAnalysis.RefKind.Ref -F:Microsoft.CodeAnalysis.RefKind.RefReadOnly -F:Microsoft.CodeAnalysis.RefKind.RefReadOnlyParameter -F:Microsoft.CodeAnalysis.RefKind.value__ -F:Microsoft.CodeAnalysis.ReportDiagnostic.Default -F:Microsoft.CodeAnalysis.ReportDiagnostic.Error -F:Microsoft.CodeAnalysis.ReportDiagnostic.Hidden -F:Microsoft.CodeAnalysis.ReportDiagnostic.Info -F:Microsoft.CodeAnalysis.ReportDiagnostic.Suppress -F:Microsoft.CodeAnalysis.ReportDiagnostic.value__ -F:Microsoft.CodeAnalysis.ReportDiagnostic.Warn -F:Microsoft.CodeAnalysis.RuntimeCapability.ByRefFields -F:Microsoft.CodeAnalysis.RuntimeCapability.ByRefLikeGenerics -F:Microsoft.CodeAnalysis.RuntimeCapability.CovariantReturnsOfClasses -F:Microsoft.CodeAnalysis.RuntimeCapability.DefaultImplementationsOfInterfaces -F:Microsoft.CodeAnalysis.RuntimeCapability.InlineArrayTypes -F:Microsoft.CodeAnalysis.RuntimeCapability.NumericIntPtr -F:Microsoft.CodeAnalysis.RuntimeCapability.UnmanagedSignatureCallingConvention -F:Microsoft.CodeAnalysis.RuntimeCapability.value__ -F:Microsoft.CodeAnalysis.RuntimeCapability.VirtualStaticsInInterfaces -F:Microsoft.CodeAnalysis.SarifVersion.Default -F:Microsoft.CodeAnalysis.SarifVersion.Latest -F:Microsoft.CodeAnalysis.SarifVersion.Sarif1 -F:Microsoft.CodeAnalysis.SarifVersion.Sarif2 -F:Microsoft.CodeAnalysis.SarifVersion.value__ -F:Microsoft.CodeAnalysis.ScopedKind.None -F:Microsoft.CodeAnalysis.ScopedKind.ScopedRef -F:Microsoft.CodeAnalysis.ScopedKind.ScopedValue -F:Microsoft.CodeAnalysis.ScopedKind.value__ -F:Microsoft.CodeAnalysis.SemanticModelOptions.DisableNullableAnalysis -F:Microsoft.CodeAnalysis.SemanticModelOptions.IgnoreAccessibility -F:Microsoft.CodeAnalysis.SemanticModelOptions.None -F:Microsoft.CodeAnalysis.SemanticModelOptions.value__ -F:Microsoft.CodeAnalysis.SourceCodeKind.Interactive -F:Microsoft.CodeAnalysis.SourceCodeKind.Regular -F:Microsoft.CodeAnalysis.SourceCodeKind.Script -F:Microsoft.CodeAnalysis.SourceCodeKind.value__ -F:Microsoft.CodeAnalysis.SpecialType.Count -F:Microsoft.CodeAnalysis.SpecialType.None -F:Microsoft.CodeAnalysis.SpecialType.System_ArgIterator -F:Microsoft.CodeAnalysis.SpecialType.System_Array -F:Microsoft.CodeAnalysis.SpecialType.System_AsyncCallback -F:Microsoft.CodeAnalysis.SpecialType.System_Boolean -F:Microsoft.CodeAnalysis.SpecialType.System_Byte -F:Microsoft.CodeAnalysis.SpecialType.System_Char -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_ICollection_T -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IEnumerable_T -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IEnumerator_T -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IList_T -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IReadOnlyCollection_T -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_Generic_IReadOnlyList_T -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_IEnumerable -F:Microsoft.CodeAnalysis.SpecialType.System_Collections_IEnumerator -F:Microsoft.CodeAnalysis.SpecialType.System_DateTime -F:Microsoft.CodeAnalysis.SpecialType.System_Decimal -F:Microsoft.CodeAnalysis.SpecialType.System_Delegate -F:Microsoft.CodeAnalysis.SpecialType.System_Double -F:Microsoft.CodeAnalysis.SpecialType.System_Enum -F:Microsoft.CodeAnalysis.SpecialType.System_IAsyncResult -F:Microsoft.CodeAnalysis.SpecialType.System_IDisposable -F:Microsoft.CodeAnalysis.SpecialType.System_Int16 -F:Microsoft.CodeAnalysis.SpecialType.System_Int32 -F:Microsoft.CodeAnalysis.SpecialType.System_Int64 -F:Microsoft.CodeAnalysis.SpecialType.System_IntPtr -F:Microsoft.CodeAnalysis.SpecialType.System_MulticastDelegate -F:Microsoft.CodeAnalysis.SpecialType.System_Nullable_T -F:Microsoft.CodeAnalysis.SpecialType.System_Object -F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute -F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_IsVolatile -F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute -F:Microsoft.CodeAnalysis.SpecialType.System_Runtime_CompilerServices_RuntimeFeature -F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeArgumentHandle -F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeFieldHandle -F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeMethodHandle -F:Microsoft.CodeAnalysis.SpecialType.System_RuntimeTypeHandle -F:Microsoft.CodeAnalysis.SpecialType.System_SByte -F:Microsoft.CodeAnalysis.SpecialType.System_Single -F:Microsoft.CodeAnalysis.SpecialType.System_String -F:Microsoft.CodeAnalysis.SpecialType.System_TypedReference -F:Microsoft.CodeAnalysis.SpecialType.System_UInt16 -F:Microsoft.CodeAnalysis.SpecialType.System_UInt32 -F:Microsoft.CodeAnalysis.SpecialType.System_UInt64 -F:Microsoft.CodeAnalysis.SpecialType.System_UIntPtr -F:Microsoft.CodeAnalysis.SpecialType.System_ValueType -F:Microsoft.CodeAnalysis.SpecialType.System_Void -F:Microsoft.CodeAnalysis.SpecialType.value__ -F:Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsExpression -F:Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsTypeOrNamespace -F:Microsoft.CodeAnalysis.SpeculativeBindingOption.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameAndParameters -F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameAndSignature -F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.NameOnly -F:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.Default -F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.InstanceMethod -F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.StaticMethod -F:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeTypeConstraints -F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeTypeParameters -F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.IncludeVariance -F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.None -F:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.Included -F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.Omitted -F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining -F:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeMemberKeyword -F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeNamespaceKeyword -F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.IncludeTypeKeyword -F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.None -F:Microsoft.CodeAnalysis.SymbolDisplayKindOptions.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeConstantValue -F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeModifiers -F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeRef -F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeType -F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.None -F:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeAccessibility -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeConstantValue -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeContainingType -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeExplicitInterface -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeModifiers -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeParameters -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeRef -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.IncludeType -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.None -F:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.CollapseTupleTypes -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.ExpandNullable -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.ExpandValueTuple -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.IncludeNotNullableReferenceTypeModifier -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.None -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.RemoveAttributeSuffix -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseAsterisksInMultiDimensionalArrays -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseErrorTypeSymbolName -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.UseSpecialTypes -F:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeDefaultValue -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeExtensionThis -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeModifiers -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeName -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeOptionalBrackets -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeParamsRefOut -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeType -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.None -F:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.AliasName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.AnonymousTypeIndicator -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.AssemblyName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ClassName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ConstantName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.DelegateName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.EnumMemberName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.EnumName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ErrorTypeName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.EventName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ExtensionMethodName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.FieldName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.InterfaceName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Keyword -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.LabelName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.LineBreak -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.LocalName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.MethodName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ModuleName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.NamespaceName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.NumericLiteral -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Operator -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.ParameterName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.PropertyName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Punctuation -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.RangeVariableName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordClassName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordStructName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Space -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.StringLiteral -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.StructName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.Text -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.TypeParameterName -F:Microsoft.CodeAnalysis.SymbolDisplayPartKind.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.NameOnly -F:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.ShowReadWriteDescriptor -F:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle.value__ -F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameAndContainingTypes -F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces -F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.NameOnly -F:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle.value__ -F:Microsoft.CodeAnalysis.SymbolEqualityComparer.Default -F:Microsoft.CodeAnalysis.SymbolEqualityComparer.IncludeNullability -F:Microsoft.CodeAnalysis.SymbolFilter.All -F:Microsoft.CodeAnalysis.SymbolFilter.Member -F:Microsoft.CodeAnalysis.SymbolFilter.Namespace -F:Microsoft.CodeAnalysis.SymbolFilter.None -F:Microsoft.CodeAnalysis.SymbolFilter.Type -F:Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember -F:Microsoft.CodeAnalysis.SymbolFilter.value__ -F:Microsoft.CodeAnalysis.SymbolKind.Alias -F:Microsoft.CodeAnalysis.SymbolKind.ArrayType -F:Microsoft.CodeAnalysis.SymbolKind.Assembly -F:Microsoft.CodeAnalysis.SymbolKind.Discard -F:Microsoft.CodeAnalysis.SymbolKind.DynamicType -F:Microsoft.CodeAnalysis.SymbolKind.ErrorType -F:Microsoft.CodeAnalysis.SymbolKind.Event -F:Microsoft.CodeAnalysis.SymbolKind.Field -F:Microsoft.CodeAnalysis.SymbolKind.FunctionPointerType -F:Microsoft.CodeAnalysis.SymbolKind.Label -F:Microsoft.CodeAnalysis.SymbolKind.Local -F:Microsoft.CodeAnalysis.SymbolKind.Method -F:Microsoft.CodeAnalysis.SymbolKind.NamedType -F:Microsoft.CodeAnalysis.SymbolKind.Namespace -F:Microsoft.CodeAnalysis.SymbolKind.NetModule -F:Microsoft.CodeAnalysis.SymbolKind.Parameter -F:Microsoft.CodeAnalysis.SymbolKind.PointerType -F:Microsoft.CodeAnalysis.SymbolKind.Preprocessing -F:Microsoft.CodeAnalysis.SymbolKind.Property -F:Microsoft.CodeAnalysis.SymbolKind.RangeVariable -F:Microsoft.CodeAnalysis.SymbolKind.TypeParameter -F:Microsoft.CodeAnalysis.SymbolKind.value__ -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.AddElasticMarker -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepDirectives -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepEndOfLine -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepExteriorTrivia -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepLeadingTrivia -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepNoTrivia -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepTrailingTrivia -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.KeepUnbalancedDirectives -F:Microsoft.CodeAnalysis.SyntaxRemoveOptions.value__ -F:Microsoft.CodeAnalysis.SyntaxTree.EmptyDiagnosticOptions -F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.Node -F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.StructuredTrivia -F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.Token -F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.Trivia -F:Microsoft.CodeAnalysis.SyntaxWalkerDepth.value__ -F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.None -F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha1 -F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha256 -F:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.value__ -F:Microsoft.CodeAnalysis.TypedConstantKind.Array -F:Microsoft.CodeAnalysis.TypedConstantKind.Enum -F:Microsoft.CodeAnalysis.TypedConstantKind.Error -F:Microsoft.CodeAnalysis.TypedConstantKind.Primitive -F:Microsoft.CodeAnalysis.TypedConstantKind.Type -F:Microsoft.CodeAnalysis.TypedConstantKind.value__ -F:Microsoft.CodeAnalysis.TypeKind.Array -F:Microsoft.CodeAnalysis.TypeKind.Class -F:Microsoft.CodeAnalysis.TypeKind.Delegate -F:Microsoft.CodeAnalysis.TypeKind.Dynamic -F:Microsoft.CodeAnalysis.TypeKind.Enum -F:Microsoft.CodeAnalysis.TypeKind.Error -F:Microsoft.CodeAnalysis.TypeKind.FunctionPointer -F:Microsoft.CodeAnalysis.TypeKind.Interface -F:Microsoft.CodeAnalysis.TypeKind.Module -F:Microsoft.CodeAnalysis.TypeKind.Pointer -F:Microsoft.CodeAnalysis.TypeKind.Struct -F:Microsoft.CodeAnalysis.TypeKind.Structure -F:Microsoft.CodeAnalysis.TypeKind.Submission -F:Microsoft.CodeAnalysis.TypeKind.TypeParameter -F:Microsoft.CodeAnalysis.TypeKind.Unknown -F:Microsoft.CodeAnalysis.TypeKind.value__ -F:Microsoft.CodeAnalysis.TypeParameterKind.Cref -F:Microsoft.CodeAnalysis.TypeParameterKind.Method -F:Microsoft.CodeAnalysis.TypeParameterKind.Type -F:Microsoft.CodeAnalysis.TypeParameterKind.value__ -F:Microsoft.CodeAnalysis.VarianceKind.In -F:Microsoft.CodeAnalysis.VarianceKind.None -F:Microsoft.CodeAnalysis.VarianceKind.Out -F:Microsoft.CodeAnalysis.VarianceKind.value__ -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.AnalyzerException -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Build -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CompilationEnd -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Compiler -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CustomObsolete -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CustomSeverityConfigurable -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.EditAndContinue -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.NotConfigurable -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Telemetry -F:Microsoft.CodeAnalysis.WellKnownDiagnosticTags.Unnecessary -F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.AdditionalTexts -F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.AnalyzerConfigOptions -F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.Compilation -F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.MetadataReferences -F:Microsoft.CodeAnalysis.WellKnownGeneratorInputs.ParseOptions -F:Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.ImplementationSourceOutput -F:Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.SourceOutput -F:Microsoft.CodeAnalysis.WellKnownMemberNames.AdditionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.BitwiseAndOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.BitwiseOrOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedAdditionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedDecrementOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedDivisionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedExplicitConversionName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedIncrementOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedMultiplyOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedSubtractionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CheckedUnaryNegationOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CollectionInitializerAddMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ConcatenateOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CountPropertyName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.CurrentPropertyName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DeconstructMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DecrementOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DefaultScriptClassName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateBeginInvokeName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateEndInvokeName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DelegateInvokeName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DestructorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DisposeAsyncMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DisposeMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.DivisionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.EntryPointMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.EnumBackingFieldName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.EqualityOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ExclusiveOrOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ExplicitConversionName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ExponentOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.FalseOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetAsyncEnumeratorMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetAwaiter -F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetEnumeratorMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.GetResult -F:Microsoft.CodeAnalysis.WellKnownMemberNames.GreaterThanOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.GreaterThanOrEqualOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ImplicitConversionName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.IncrementOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.Indexer -F:Microsoft.CodeAnalysis.WellKnownMemberNames.InequalityOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.InstanceConstructorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.IntegerDivisionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.IsCompleted -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LeftShiftOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LengthPropertyName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LessThanOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LessThanOrEqualOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LikeOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalAndOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalNotOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.LogicalOrOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ModulusOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextAsyncMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.MultiplyOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectEquals -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectGetHashCode -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ObjectToString -F:Microsoft.CodeAnalysis.WellKnownMemberNames.OnCompleted -F:Microsoft.CodeAnalysis.WellKnownMemberNames.OnesComplementOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.PrintMembersMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.RightShiftOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.SliceMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.StaticConstructorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.SubtractionOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.TopLevelStatementsEntryPointMethodName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.TopLevelStatementsEntryPointTypeName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.TrueOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnaryNegationOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnaryPlusOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnsignedLeftShiftOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.UnsignedRightShiftOperatorName -F:Microsoft.CodeAnalysis.WellKnownMemberNames.ValuePropertyName -M:Microsoft.CodeAnalysis.AdditionalText.#ctor -M:Microsoft.CodeAnalysis.AdditionalText.get_Path -M:Microsoft.CodeAnalysis.AdditionalText.GetText(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.AnalyzerConfig.Parse(Microsoft.CodeAnalysis.Text.SourceText,System.String) -M:Microsoft.CodeAnalysis.AnalyzerConfig.Parse(System.String,System.String) -M:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_AnalyzerOptions -M:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_Diagnostics -M:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult.get_TreeOptions -M:Microsoft.CodeAnalysis.AnalyzerConfigSet.Create``1(``0) -M:Microsoft.CodeAnalysis.AnalyzerConfigSet.Create``1(``0,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic}@) -M:Microsoft.CodeAnalysis.AnalyzerConfigSet.get_GlobalConfigOptions -M:Microsoft.CodeAnalysis.AnalyzerConfigSet.GetOptionsForSourcePath(System.String) -M:Microsoft.CodeAnalysis.AnnotationExtensions.WithAdditionalAnnotations``1(``0,Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.AnnotationExtensions.WithAdditionalAnnotations``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.AnnotationExtensions.WithoutAnnotations``1(``0,System.String) -M:Microsoft.CodeAnalysis.AssemblyIdentity.#ctor(System.String,System.Version,System.String,System.Collections.Immutable.ImmutableArray{System.Byte},System.Boolean,System.Boolean,System.Reflection.AssemblyContentType) -M:Microsoft.CodeAnalysis.AssemblyIdentity.Equals(Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.AssemblyIdentity.Equals(System.Object) -M:Microsoft.CodeAnalysis.AssemblyIdentity.FromAssemblyDefinition(System.Reflection.Assembly) -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_ContentType -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_CultureName -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_Flags -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_HasPublicKey -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_IsRetargetable -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_IsStrongName -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_Name -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_PublicKey -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_PublicKeyToken -M:Microsoft.CodeAnalysis.AssemblyIdentity.get_Version -M:Microsoft.CodeAnalysis.AssemblyIdentity.GetDisplayName(System.Boolean) -M:Microsoft.CodeAnalysis.AssemblyIdentity.GetHashCode -M:Microsoft.CodeAnalysis.AssemblyIdentity.op_Equality(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.AssemblyIdentity.op_Inequality(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.AssemblyIdentity.ToString -M:Microsoft.CodeAnalysis.AssemblyIdentity.TryParseDisplayName(System.String,Microsoft.CodeAnalysis.AssemblyIdentity@) -M:Microsoft.CodeAnalysis.AssemblyIdentity.TryParseDisplayName(System.String,Microsoft.CodeAnalysis.AssemblyIdentity@,Microsoft.CodeAnalysis.AssemblyIdentityParts@) -M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.Compare(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_CultureComparer -M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_Default -M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.get_SimpleNameComparer -M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ReferenceMatchesDefinition(Microsoft.CodeAnalysis.AssemblyIdentity,Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ReferenceMatchesDefinition(System.String,Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.AssemblyMetadata.CommonCopy -M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(Microsoft.CodeAnalysis.ModuleMetadata) -M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(Microsoft.CodeAnalysis.ModuleMetadata[]) -M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ModuleMetadata}) -M:Microsoft.CodeAnalysis.AssemblyMetadata.Create(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ModuleMetadata}) -M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromFile(System.String) -M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromImage(System.Collections.Generic.IEnumerable{System.Byte}) -M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromImage(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromStream(System.IO.Stream,System.Boolean) -M:Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromStream(System.IO.Stream,System.Reflection.PortableExecutable.PEStreamOptions) -M:Microsoft.CodeAnalysis.AssemblyMetadata.Dispose -M:Microsoft.CodeAnalysis.AssemblyMetadata.get_Kind -M:Microsoft.CodeAnalysis.AssemblyMetadata.GetModules -M:Microsoft.CodeAnalysis.AssemblyMetadata.GetReference(Microsoft.CodeAnalysis.DocumentationProvider,System.Collections.Immutable.ImmutableArray{System.String},System.Boolean,System.String,System.String) -M:Microsoft.CodeAnalysis.AttributeData.#ctor -M:Microsoft.CodeAnalysis.AttributeData.get_ApplicationSyntaxReference -M:Microsoft.CodeAnalysis.AttributeData.get_AttributeClass -M:Microsoft.CodeAnalysis.AttributeData.get_AttributeConstructor -M:Microsoft.CodeAnalysis.AttributeData.get_CommonApplicationSyntaxReference -M:Microsoft.CodeAnalysis.AttributeData.get_CommonAttributeClass -M:Microsoft.CodeAnalysis.AttributeData.get_CommonAttributeConstructor -M:Microsoft.CodeAnalysis.AttributeData.get_CommonConstructorArguments -M:Microsoft.CodeAnalysis.AttributeData.get_CommonNamedArguments -M:Microsoft.CodeAnalysis.AttributeData.get_ConstructorArguments -M:Microsoft.CodeAnalysis.AttributeData.get_NamedArguments -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.String,System.String) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.EndsWith(System.String,System.String) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.String,System.String) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.get_Comparer -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.GetHashCode(System.String) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.StartsWith(System.String,System.String) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.Char) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.String) -M:Microsoft.CodeAnalysis.CaseInsensitiveComparison.ToLower(System.Text.StringBuilder) -M:Microsoft.CodeAnalysis.ChildSyntaxList.Any -M:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.get_Current -M:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator.Reset -M:Microsoft.CodeAnalysis.ChildSyntaxList.Equals(Microsoft.CodeAnalysis.ChildSyntaxList) -M:Microsoft.CodeAnalysis.ChildSyntaxList.Equals(System.Object) -M:Microsoft.CodeAnalysis.ChildSyntaxList.First -M:Microsoft.CodeAnalysis.ChildSyntaxList.get_Count -M:Microsoft.CodeAnalysis.ChildSyntaxList.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.ChildSyntaxList.GetEnumerator -M:Microsoft.CodeAnalysis.ChildSyntaxList.GetHashCode -M:Microsoft.CodeAnalysis.ChildSyntaxList.Last -M:Microsoft.CodeAnalysis.ChildSyntaxList.op_Equality(Microsoft.CodeAnalysis.ChildSyntaxList,Microsoft.CodeAnalysis.ChildSyntaxList) -M:Microsoft.CodeAnalysis.ChildSyntaxList.op_Inequality(Microsoft.CodeAnalysis.ChildSyntaxList,Microsoft.CodeAnalysis.ChildSyntaxList) -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reverse -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.get_Current -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator.Reset -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Equals(Microsoft.CodeAnalysis.ChildSyntaxList.Reversed) -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Equals(System.Object) -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.GetEnumerator -M:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.GetHashCode -M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.#ctor(System.String) -M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.Equals(Microsoft.CodeAnalysis.CommandLineAnalyzerReference) -M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.Equals(System.Object) -M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.get_FilePath -M:Microsoft.CodeAnalysis.CommandLineAnalyzerReference.GetHashCode -M:Microsoft.CodeAnalysis.CommandLineArguments.get_AdditionalFiles -M:Microsoft.CodeAnalysis.CommandLineArguments.get_AnalyzerConfigPaths -M:Microsoft.CodeAnalysis.CommandLineArguments.get_AnalyzerReferences -M:Microsoft.CodeAnalysis.CommandLineArguments.get_AppConfigPath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_BaseDirectory -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ChecksumAlgorithm -M:Microsoft.CodeAnalysis.CommandLineArguments.get_CompilationName -M:Microsoft.CodeAnalysis.CommandLineArguments.get_CompilationOptions -M:Microsoft.CodeAnalysis.CommandLineArguments.get_CompilationOptionsCore -M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayHelp -M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayLangVersions -M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayLogo -M:Microsoft.CodeAnalysis.CommandLineArguments.get_DisplayVersion -M:Microsoft.CodeAnalysis.CommandLineArguments.get_DocumentationPath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmbeddedFiles -M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmitOptions -M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmitPdb -M:Microsoft.CodeAnalysis.CommandLineArguments.get_EmitPdbFile -M:Microsoft.CodeAnalysis.CommandLineArguments.get_Encoding -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ErrorLogOptions -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ErrorLogPath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_Errors -M:Microsoft.CodeAnalysis.CommandLineArguments.get_GeneratedFilesOutputDirectory -M:Microsoft.CodeAnalysis.CommandLineArguments.get_InteractiveMode -M:Microsoft.CodeAnalysis.CommandLineArguments.get_KeyFileSearchPaths -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ManifestResources -M:Microsoft.CodeAnalysis.CommandLineArguments.get_MetadataReferences -M:Microsoft.CodeAnalysis.CommandLineArguments.get_NoWin32Manifest -M:Microsoft.CodeAnalysis.CommandLineArguments.get_OutputDirectory -M:Microsoft.CodeAnalysis.CommandLineArguments.get_OutputFileName -M:Microsoft.CodeAnalysis.CommandLineArguments.get_OutputRefFilePath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ParseOptions -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ParseOptionsCore -M:Microsoft.CodeAnalysis.CommandLineArguments.get_PathMap -M:Microsoft.CodeAnalysis.CommandLineArguments.get_PdbPath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_PreferredUILang -M:Microsoft.CodeAnalysis.CommandLineArguments.get_PrintFullPaths -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ReferencePaths -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ReportAnalyzer -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ReportInternalsVisibleToAttributes -M:Microsoft.CodeAnalysis.CommandLineArguments.get_RuleSetPath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_ScriptArguments -M:Microsoft.CodeAnalysis.CommandLineArguments.get_SkipAnalyzers -M:Microsoft.CodeAnalysis.CommandLineArguments.get_SourceFiles -M:Microsoft.CodeAnalysis.CommandLineArguments.get_SourceLink -M:Microsoft.CodeAnalysis.CommandLineArguments.get_SourcePaths -M:Microsoft.CodeAnalysis.CommandLineArguments.get_TouchedFilesPath -M:Microsoft.CodeAnalysis.CommandLineArguments.get_Utf8Output -M:Microsoft.CodeAnalysis.CommandLineArguments.get_Win32Icon -M:Microsoft.CodeAnalysis.CommandLineArguments.get_Win32Manifest -M:Microsoft.CodeAnalysis.CommandLineArguments.get_Win32ResourceFile -M:Microsoft.CodeAnalysis.CommandLineArguments.GetOutputFilePath(System.String) -M:Microsoft.CodeAnalysis.CommandLineArguments.GetPdbFilePath(System.String) -M:Microsoft.CodeAnalysis.CommandLineArguments.ResolveAnalyzerReferences(Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader) -M:Microsoft.CodeAnalysis.CommandLineArguments.ResolveMetadataReferences(Microsoft.CodeAnalysis.MetadataReferenceResolver) -M:Microsoft.CodeAnalysis.CommandLineReference.#ctor(System.String,Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.CommandLineReference.Equals(Microsoft.CodeAnalysis.CommandLineReference) -M:Microsoft.CodeAnalysis.CommandLineReference.Equals(System.Object) -M:Microsoft.CodeAnalysis.CommandLineReference.get_Properties -M:Microsoft.CodeAnalysis.CommandLineReference.get_Reference -M:Microsoft.CodeAnalysis.CommandLineReference.GetHashCode -M:Microsoft.CodeAnalysis.CommandLineSourceFile.#ctor(System.String,System.Boolean) -M:Microsoft.CodeAnalysis.CommandLineSourceFile.#ctor(System.String,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.CommandLineSourceFile.get_IsInputRedirected -M:Microsoft.CodeAnalysis.CommandLineSourceFile.get_IsScript -M:Microsoft.CodeAnalysis.CommandLineSourceFile.get_Path -M:Microsoft.CodeAnalysis.Compilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference[]) -M:Microsoft.CodeAnalysis.Compilation.AddReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.Compilation.AddSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) -M:Microsoft.CodeAnalysis.Compilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.Compilation.AppendDefaultVersionResource(System.IO.Stream) -M:Microsoft.CodeAnalysis.Compilation.CheckTupleElementLocations(System.Int32,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) -M:Microsoft.CodeAnalysis.Compilation.CheckTupleElementNames(System.Int32,System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.Compilation.CheckTupleElementNullableAnnotations(System.Int32,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.Clone -M:Microsoft.CodeAnalysis.Compilation.CommonAddSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.Compilation.CommonBindScriptClass -M:Microsoft.CodeAnalysis.Compilation.CommonClone -M:Microsoft.CodeAnalysis.Compilation.CommonContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateNativeIntegerTypeSymbol(System.Boolean) -M:Microsoft.CodeAnalysis.Compilation.CommonCreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.CommonCreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.CommonGetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) -M:Microsoft.CodeAnalysis.Compilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) -M:Microsoft.CodeAnalysis.Compilation.CommonGetEntryPoint(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) -M:Microsoft.CodeAnalysis.Compilation.CommonGetTypeByMetadataName(System.String) -M:Microsoft.CodeAnalysis.Compilation.CommonRemoveAllSyntaxTrees -M:Microsoft.CodeAnalysis.Compilation.CommonRemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.Compilation.CommonReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.Compilation.CommonWithAssemblyName(System.String) -M:Microsoft.CodeAnalysis.Compilation.CommonWithOptions(Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.Compilation.CommonWithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.Compilation.CommonWithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) -M:Microsoft.CodeAnalysis.Compilation.ContainsSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.ContainsSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) -M:Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{System.Boolean},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.CreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32) -M:Microsoft.CodeAnalysis.Compilation.CreateArrayTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.NullableAnnotation) -M:Microsoft.CodeAnalysis.Compilation.CreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.CreateBuiltinOperator(System.String,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.CreateDefaultWin32Resources(System.Boolean,System.Boolean,System.IO.Stream,System.IO.Stream) -M:Microsoft.CodeAnalysis.Compilation.CreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol,System.String) -M:Microsoft.CodeAnalysis.Compilation.CreateErrorTypeSymbol(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Int32) -M:Microsoft.CodeAnalysis.Compilation.CreateFunctionPointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.RefKind,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RefKind},System.Reflection.Metadata.SignatureCallingConvention,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.INamedTypeSymbol}) -M:Microsoft.CodeAnalysis.Compilation.CreateNativeIntegerTypeSymbol(System.Boolean) -M:Microsoft.CodeAnalysis.Compilation.CreatePointerTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) -M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol,System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location}) -M:Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{System.String},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.IMethodSymbol,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.EmbeddedText},System.IO.Stream,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.IMethodSymbol,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.EmbeddedText},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream,System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.ResourceDescription},Microsoft.CodeAnalysis.Emit.EmitOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Emit.SemanticEdit},System.Func{Microsoft.CodeAnalysis.ISymbol,System.Boolean},System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.ICollection{System.Reflection.Metadata.MethodDefinitionHandle},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Emit.SemanticEdit},System.Func{Microsoft.CodeAnalysis.ISymbol,System.Boolean},System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Emit.SemanticEdit},System.IO.Stream,System.IO.Stream,System.IO.Stream,System.Collections.Generic.ICollection{System.Reflection.Metadata.MethodDefinitionHandle},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.get_Assembly -M:Microsoft.CodeAnalysis.Compilation.get_AssemblyName -M:Microsoft.CodeAnalysis.Compilation.get_CommonAssembly -M:Microsoft.CodeAnalysis.Compilation.get_CommonDynamicType -M:Microsoft.CodeAnalysis.Compilation.get_CommonGlobalNamespace -M:Microsoft.CodeAnalysis.Compilation.get_CommonObjectType -M:Microsoft.CodeAnalysis.Compilation.get_CommonOptions -M:Microsoft.CodeAnalysis.Compilation.get_CommonScriptClass -M:Microsoft.CodeAnalysis.Compilation.get_CommonScriptGlobalsType -M:Microsoft.CodeAnalysis.Compilation.get_CommonSourceModule -M:Microsoft.CodeAnalysis.Compilation.get_CommonSyntaxTrees -M:Microsoft.CodeAnalysis.Compilation.get_DirectiveReferences -M:Microsoft.CodeAnalysis.Compilation.get_DynamicType -M:Microsoft.CodeAnalysis.Compilation.get_ExternalReferences -M:Microsoft.CodeAnalysis.Compilation.get_GlobalNamespace -M:Microsoft.CodeAnalysis.Compilation.get_IsCaseSensitive -M:Microsoft.CodeAnalysis.Compilation.get_Language -M:Microsoft.CodeAnalysis.Compilation.get_ObjectType -M:Microsoft.CodeAnalysis.Compilation.get_Options -M:Microsoft.CodeAnalysis.Compilation.get_ReferencedAssemblyNames -M:Microsoft.CodeAnalysis.Compilation.get_References -M:Microsoft.CodeAnalysis.Compilation.get_ScriptClass -M:Microsoft.CodeAnalysis.Compilation.get_ScriptCompilationInfo -M:Microsoft.CodeAnalysis.Compilation.get_SourceModule -M:Microsoft.CodeAnalysis.Compilation.get_SyntaxTrees -M:Microsoft.CodeAnalysis.Compilation.GetAssemblyOrModuleSymbol(Microsoft.CodeAnalysis.MetadataReference) -M:Microsoft.CodeAnalysis.Compilation.GetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) -M:Microsoft.CodeAnalysis.Compilation.GetDeclarationDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetEntryPoint(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol) -M:Microsoft.CodeAnalysis.Compilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetParseDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetRequiredLanguageVersion(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SemanticModelOptions) -M:Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) -M:Microsoft.CodeAnalysis.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType) -M:Microsoft.CodeAnalysis.Compilation.GetSymbolsWithName(System.Func{System.String,System.Boolean},Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetSymbolsWithName(System.String,Microsoft.CodeAnalysis.SymbolFilter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.GetTypeByMetadataName(System.String) -M:Microsoft.CodeAnalysis.Compilation.GetTypesByMetadataName(System.String) -M:Microsoft.CodeAnalysis.Compilation.GetUnreferencedAssemblyIdentities(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Compilation.GetUsedAssemblyReferences(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Compilation.HasImplicitConversion(Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.IsSymbolAccessibleWithin(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.Compilation.RemoveAllReferences -M:Microsoft.CodeAnalysis.Compilation.RemoveAllSyntaxTrees -M:Microsoft.CodeAnalysis.Compilation.RemoveReferences(Microsoft.CodeAnalysis.MetadataReference[]) -M:Microsoft.CodeAnalysis.Compilation.RemoveReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(Microsoft.CodeAnalysis.SyntaxTree[]) -M:Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.Compilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.MetadataReference) -M:Microsoft.CodeAnalysis.Compilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.Compilation.SupportsRuntimeCapability(Microsoft.CodeAnalysis.RuntimeCapability) -M:Microsoft.CodeAnalysis.Compilation.SyntaxTreeCommonFeatures(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.Compilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) -M:Microsoft.CodeAnalysis.Compilation.WithAssemblyName(System.String) -M:Microsoft.CodeAnalysis.Compilation.WithOptions(Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.Compilation.WithReferences(Microsoft.CodeAnalysis.MetadataReference[]) -M:Microsoft.CodeAnalysis.Compilation.WithReferences(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.MetadataReference}) -M:Microsoft.CodeAnalysis.Compilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.ScriptCompilationInfo) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCheckOverflow(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithConcurrentBuild(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoKeyContainer(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoKeyFile(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithDelaySign(System.Nullable{System.Boolean}) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithDeterministic(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithFeatures(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithMainTypeName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithModuleName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithOutputKind(Microsoft.CodeAnalysis.OutputKind) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithPlatform(Microsoft.CodeAnalysis.Platform) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithPublicSign(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithReportSuppressedDiagnostics(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithScriptClassName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) -M:Microsoft.CodeAnalysis.CompilationOptions.CommonWithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.ComputeHashCode -M:Microsoft.CodeAnalysis.CompilationOptions.Equals(System.Object) -M:Microsoft.CodeAnalysis.CompilationOptions.EqualsHelper(Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.get_AssemblyIdentityComparer -M:Microsoft.CodeAnalysis.CompilationOptions.get_CheckOverflow -M:Microsoft.CodeAnalysis.CompilationOptions.get_ConcurrentBuild -M:Microsoft.CodeAnalysis.CompilationOptions.get_CryptoKeyContainer -M:Microsoft.CodeAnalysis.CompilationOptions.get_CryptoKeyFile -M:Microsoft.CodeAnalysis.CompilationOptions.get_CryptoPublicKey -M:Microsoft.CodeAnalysis.CompilationOptions.get_DelaySign -M:Microsoft.CodeAnalysis.CompilationOptions.get_Deterministic -M:Microsoft.CodeAnalysis.CompilationOptions.get_Errors -M:Microsoft.CodeAnalysis.CompilationOptions.get_Features -M:Microsoft.CodeAnalysis.CompilationOptions.get_GeneralDiagnosticOption -M:Microsoft.CodeAnalysis.CompilationOptions.get_Language -M:Microsoft.CodeAnalysis.CompilationOptions.get_MainTypeName -M:Microsoft.CodeAnalysis.CompilationOptions.get_MetadataImportOptions -M:Microsoft.CodeAnalysis.CompilationOptions.get_MetadataReferenceResolver -M:Microsoft.CodeAnalysis.CompilationOptions.get_ModuleName -M:Microsoft.CodeAnalysis.CompilationOptions.get_NullableContextOptions -M:Microsoft.CodeAnalysis.CompilationOptions.get_OptimizationLevel -M:Microsoft.CodeAnalysis.CompilationOptions.get_OutputKind -M:Microsoft.CodeAnalysis.CompilationOptions.get_Platform -M:Microsoft.CodeAnalysis.CompilationOptions.get_PublicSign -M:Microsoft.CodeAnalysis.CompilationOptions.get_ReportSuppressedDiagnostics -M:Microsoft.CodeAnalysis.CompilationOptions.get_ScriptClassName -M:Microsoft.CodeAnalysis.CompilationOptions.get_SourceReferenceResolver -M:Microsoft.CodeAnalysis.CompilationOptions.get_SpecificDiagnosticOptions -M:Microsoft.CodeAnalysis.CompilationOptions.get_StrongNameProvider -M:Microsoft.CodeAnalysis.CompilationOptions.get_SyntaxTreeOptionsProvider -M:Microsoft.CodeAnalysis.CompilationOptions.get_WarningLevel -M:Microsoft.CodeAnalysis.CompilationOptions.get_XmlReferenceResolver -M:Microsoft.CodeAnalysis.CompilationOptions.GetHashCode -M:Microsoft.CodeAnalysis.CompilationOptions.GetHashCodeHelper -M:Microsoft.CodeAnalysis.CompilationOptions.op_Equality(Microsoft.CodeAnalysis.CompilationOptions,Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.op_Inequality(Microsoft.CodeAnalysis.CompilationOptions,Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.set_AssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) -M:Microsoft.CodeAnalysis.CompilationOptions.set_CheckOverflow(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.set_ConcurrentBuild(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.set_CryptoKeyContainer(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.set_CryptoKeyFile(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.set_CryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.CompilationOptions.set_DelaySign(System.Nullable{System.Boolean}) -M:Microsoft.CodeAnalysis.CompilationOptions.set_Deterministic(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.set_Features(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.CompilationOptions.set_GeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.CompilationOptions.set_MainTypeName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.set_MetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.set_MetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.set_ModuleName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.set_NullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.set_OptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) -M:Microsoft.CodeAnalysis.CompilationOptions.set_OutputKind(Microsoft.CodeAnalysis.OutputKind) -M:Microsoft.CodeAnalysis.CompilationOptions.set_Platform(Microsoft.CodeAnalysis.Platform) -M:Microsoft.CodeAnalysis.CompilationOptions.set_PublicSign(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.set_ReportSuppressedDiagnostics(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.set_ScriptClassName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.set_SourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.set_SpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.CompilationOptions.set_StrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CompilationOptions.set_SyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) -M:Microsoft.CodeAnalysis.CompilationOptions.set_WarningLevel(System.Int32) -M:Microsoft.CodeAnalysis.CompilationOptions.set_XmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer) -M:Microsoft.CodeAnalysis.CompilationOptions.WithConcurrentBuild(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoKeyContainer(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoKeyFile(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.WithCryptoPublicKey(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.CompilationOptions.WithDelaySign(System.Nullable{System.Boolean}) -M:Microsoft.CodeAnalysis.CompilationOptions.WithDeterministic(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.CompilationOptions.WithMainTypeName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions) -M:Microsoft.CodeAnalysis.CompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.WithModuleName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel) -M:Microsoft.CodeAnalysis.CompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind) -M:Microsoft.CodeAnalysis.CompilationOptions.WithOverflowChecks(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform) -M:Microsoft.CodeAnalysis.CompilationOptions.WithPublicSign(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.WithReportSuppressedDiagnostics(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationOptions.WithScriptClassName(System.String) -M:Microsoft.CodeAnalysis.CompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}}) -M:Microsoft.CodeAnalysis.CompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.CompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider) -M:Microsoft.CodeAnalysis.CompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider) -M:Microsoft.CodeAnalysis.CompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver) -M:Microsoft.CodeAnalysis.CompilationReference.Equals(Microsoft.CodeAnalysis.CompilationReference) -M:Microsoft.CodeAnalysis.CompilationReference.Equals(System.Object) -M:Microsoft.CodeAnalysis.CompilationReference.get_Compilation -M:Microsoft.CodeAnalysis.CompilationReference.get_Display -M:Microsoft.CodeAnalysis.CompilationReference.GetHashCode -M:Microsoft.CodeAnalysis.CompilationReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.CompilationReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.CompilationReference.WithEmbedInteropTypes(System.Boolean) -M:Microsoft.CodeAnalysis.CompilationReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.#ctor -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_EndPointIsReachable -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_EntryPoints -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_ExitPoints -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_ReturnStatements -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_StartPointIsReachable -M:Microsoft.CodeAnalysis.ControlFlowAnalysis.get_Succeeded -M:Microsoft.CodeAnalysis.CustomModifier.#ctor -M:Microsoft.CodeAnalysis.CustomModifier.get_IsOptional -M:Microsoft.CodeAnalysis.CustomModifier.get_Modifier -M:Microsoft.CodeAnalysis.DataFlowAnalysis.#ctor -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_AlwaysAssigned -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_Captured -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_CapturedInside -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_CapturedOutside -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DataFlowsIn -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DataFlowsOut -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DefinitelyAssignedOnEntry -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_DefinitelyAssignedOnExit -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_ReadInside -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_ReadOutside -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_Succeeded -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_UnsafeAddressTaken -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_UsedLocalFunctions -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_VariablesDeclared -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_WrittenInside -M:Microsoft.CodeAnalysis.DataFlowAnalysis.get_WrittenOutside -M:Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.get_Default -M:Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.LoadFromXml(System.IO.Stream) -M:Microsoft.CodeAnalysis.Diagnostic.#ctor -M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) -M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) -M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Object[]) -M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.Object[]) -M:Microsoft.CodeAnalysis.Diagnostic.Create(Microsoft.CodeAnalysis.DiagnosticDescriptor,Microsoft.CodeAnalysis.Location,System.Object[]) -M:Microsoft.CodeAnalysis.Diagnostic.Create(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.DiagnosticSeverity,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.Int32,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Generic.IEnumerable{System.String},System.Collections.Immutable.ImmutableDictionary{System.String,System.String}) -M:Microsoft.CodeAnalysis.Diagnostic.Create(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.DiagnosticSeverity,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.Int32,System.Boolean,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.Location,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Location},System.Collections.Generic.IEnumerable{System.String},System.Collections.Immutable.ImmutableDictionary{System.String,System.String}) -M:Microsoft.CodeAnalysis.Diagnostic.Equals(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostic.Equals(System.Object) -M:Microsoft.CodeAnalysis.Diagnostic.get_AdditionalLocations -M:Microsoft.CodeAnalysis.Diagnostic.get_DefaultSeverity -M:Microsoft.CodeAnalysis.Diagnostic.get_Descriptor -M:Microsoft.CodeAnalysis.Diagnostic.get_Id -M:Microsoft.CodeAnalysis.Diagnostic.get_IsSuppressed -M:Microsoft.CodeAnalysis.Diagnostic.get_IsWarningAsError -M:Microsoft.CodeAnalysis.Diagnostic.get_Location -M:Microsoft.CodeAnalysis.Diagnostic.get_Properties -M:Microsoft.CodeAnalysis.Diagnostic.get_Severity -M:Microsoft.CodeAnalysis.Diagnostic.get_WarningLevel -M:Microsoft.CodeAnalysis.Diagnostic.GetHashCode -M:Microsoft.CodeAnalysis.Diagnostic.GetMessage(System.IFormatProvider) -M:Microsoft.CodeAnalysis.Diagnostic.GetSuppressionInfo(Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.Diagnostic.ToString -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.#ctor(System.String,Microsoft.CodeAnalysis.LocalizableString,Microsoft.CodeAnalysis.LocalizableString,System.String,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,Microsoft.CodeAnalysis.LocalizableString,System.String,System.String[]) -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.#ctor(System.String,System.String,System.String,System.String,Microsoft.CodeAnalysis.DiagnosticSeverity,System.Boolean,System.String,System.String,System.String[]) -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.Equals(Microsoft.CodeAnalysis.DiagnosticDescriptor) -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.Equals(System.Object) -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Category -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_CustomTags -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_DefaultSeverity -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Description -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_HelpLinkUri -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Id -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_IsEnabledByDefault -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_MessageFormat -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.get_Title -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.GetEffectiveSeverity(Microsoft.CodeAnalysis.CompilationOptions) -M:Microsoft.CodeAnalysis.DiagnosticDescriptor.GetHashCode -M:Microsoft.CodeAnalysis.DiagnosticFormatter.#ctor -M:Microsoft.CodeAnalysis.DiagnosticFormatter.Format(Microsoft.CodeAnalysis.Diagnostic,System.IFormatProvider) -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_AdditionalFile -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.AdditionalText,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.AdditionalText}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.ConfigureGeneratedCodeAnalysis(Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.EnableConcurrentExecution -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.get_MinimumReportedSeverity -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterAdditionalFileAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSemanticModelAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},Microsoft.CodeAnalysis.SymbolKind[]) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolKind}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSymbolStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext},Microsoft.CodeAnalysis.SymbolKind) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterSyntaxTreeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_AdditionalFileDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_Analyzers -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_AnalyzerTelemetryInfo -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_CompilationDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_SemanticDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.get_SyntaxDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.GetAllDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult.GetAllDiagnostics(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.get_KeyComparer -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.get_Keys -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions.TryGetValue(System.String,System.String@) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.get_GlobalOptions -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.GetOptions(Microsoft.CodeAnalysis.AdditionalText) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider.GetOptions(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.#ctor(System.String,Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.add_AnalyzerLoadFailed(System.EventHandler{Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.Equals(System.Object) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_AssemblyLoader -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_Display -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_FullPath -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.get_Id -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAnalyzers(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAnalyzersForAllLanguages -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetAssembly -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGeneratorsForAllLanguages -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetHashCode -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.remove_AnalyzerLoadFailed(System.EventHandler{Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.String,System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_Display -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_FullPath -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.get_Id -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.GetAnalyzers(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference.GetAnalyzersForAllLanguages -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode,System.String,System.Exception,System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_ErrorCode -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_Exception -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_Message -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_ReferencedCompilerVersion -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.get_TypeName -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText},Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.Equals(System.Object) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.get_AdditionalFiles -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.get_AnalyzerConfigOptionsProvider -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.GetHashCode -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions.WithAdditionalFiles(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_Display -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_FullPath -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.get_Id -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetAnalyzers(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetAnalyzersForAllLanguages -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGeneratorsForAllLanguages -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_CodeBlock -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_OwningSymbol -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.get_SemanticModel -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_CodeBlock -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_OwningSymbol -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.get_SemanticModel -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterCodeBlockEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterSyntaxNodeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},`0[]) -M:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1.RegisterSyntaxNodeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{`0}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.#ctor(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.#ctor(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterAdditionalFileAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterCompilationEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSemanticModelAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},Microsoft.CodeAnalysis.SymbolKind[]) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolKind}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSymbolStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext},Microsoft.CodeAnalysis.SymbolKind) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterSyntaxTreeAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.TryGetValue``1(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider{``0},``0@) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.#ctor(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.ClearAnalyzerState(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_AnalysisOptions -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_Analyzers -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAllDiagnosticsAsync -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAllDiagnosticsAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.AdditionalText,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalysisResultAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerCompilationDiagnosticsAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerCompilationDiagnosticsAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(Microsoft.CodeAnalysis.SemanticModel,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetAnalyzerTelemetryInfoAsync(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetEffectiveDiagnostics(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Diagnostic},Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.GetEffectiveDiagnostics(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic},Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers.IsDiagnosticAnalyzerSuppressed(Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.CompilationOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.#ctor(Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{System.Exception,Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer,Microsoft.CodeAnalysis.Diagnostic},System.Boolean,System.Boolean,System.Boolean,System.Func{System.Exception,System.Boolean}) -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_AnalyzerExceptionFilter -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_ConcurrentAnalysis -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_LogAnalyzerExecutionTime -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_OnAnalyzerException -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions.get_ReportSuppressedDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.Equals(System.Object) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.get_SupportedDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.GetHashCode -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer.ToString -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute.#ctor(System.String,System.String[]) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute.get_Languages -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(Microsoft.CodeAnalysis.Compilation,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer},Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.get_SupportedDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.get_SupportedSuppressions -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext) -M:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor.ReportSuppressions(Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext) -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.#ctor(Microsoft.CodeAnalysis.IOperation,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_ContainingSymbol -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Operation -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.GetControlFlowGraph -M:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.IOperation},Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_OperationBlocks -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.get_OwningSymbol -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.GetControlFlowGraph(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.#ctor(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.IOperation},Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_OperationBlocks -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.get_OwningSymbol -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.GetControlFlowGraph(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) -M:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationBlockEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.#ctor(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.get_SemanticModel -M:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.Text.SourceText,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.Text.SourceText}) -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.Create(Microsoft.CodeAnalysis.SuppressionDescriptor,Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.Equals(Microsoft.CodeAnalysis.Diagnostics.Suppression) -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.Equals(System.Object) -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.get_Descriptor -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.get_SuppressedDiagnostic -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.GetHashCode -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.op_Equality(Microsoft.CodeAnalysis.Diagnostics.Suppression,Microsoft.CodeAnalysis.Diagnostics.Suppression) -M:Microsoft.CodeAnalysis.Diagnostics.Suppression.op_Inequality(Microsoft.CodeAnalysis.Diagnostics.Suppression,Microsoft.CodeAnalysis.Diagnostics.Suppression) -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.get_ReportedDiagnostics -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext.ReportSuppression(Microsoft.CodeAnalysis.Diagnostics.Suppression) -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_Attribute -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_Id -M:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo.get_ProgrammaticSuppressions -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.#ctor(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.get_Symbol -M:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.#ctor(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.get_Symbol -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterCodeBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterCodeBlockStartAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext{``0}}) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},Microsoft.CodeAnalysis.OperationKind[]) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.OperationKind}) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationBlockAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterOperationBlockStartAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSymbolEndAction(System.Action{Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext}) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},``0[]) -M:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext.RegisterSyntaxNodeAction``1(System.Action{Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext},System.Collections.Immutable.ImmutableArray{``0}) -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Compilation -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_ContainingSymbol -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_FilterTree -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Node -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.get_SemanticModel -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.#ctor(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions,System.Action{Microsoft.CodeAnalysis.Diagnostic},System.Func{Microsoft.CodeAnalysis.Diagnostic,System.Boolean},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_CancellationToken -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_FilterSpan -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_IsGeneratedCode -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_Options -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.get_Tree -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider`1.#ctor(System.Func{Microsoft.CodeAnalysis.SyntaxTree,`0},System.Collections.Generic.IEqualityComparer{Microsoft.CodeAnalysis.SyntaxTree}) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.#ctor -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_AdditionalFileActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockEndActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CodeBlockStartActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationEndActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_CompilationStartActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_Concurrent -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_ExecutionTime -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockEndActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_OperationBlockStartActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SemanticModelActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SuppressionActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolEndActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SymbolStartActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SyntaxNodeActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.get_SyntaxTreeActionsCount -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_AdditionalFileActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockEndActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CodeBlockStartActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationEndActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_CompilationStartActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_Concurrent(System.Boolean) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_ExecutionTime(System.TimeSpan) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockEndActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_OperationBlockStartActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SemanticModelActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SuppressionActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolEndActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SymbolStartActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SyntaxNodeActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo.set_SyntaxTreeActionsCount(System.Int32) -M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.#ctor(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_Display -M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_FullPath -M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.get_Id -M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.GetAnalyzers(System.String) -M:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference.GetAnalyzersForAllLanguages -M:Microsoft.CodeAnalysis.DllImportData.get_BestFitMapping -M:Microsoft.CodeAnalysis.DllImportData.get_CallingConvention -M:Microsoft.CodeAnalysis.DllImportData.get_CharacterSet -M:Microsoft.CodeAnalysis.DllImportData.get_EntryPointName -M:Microsoft.CodeAnalysis.DllImportData.get_ExactSpelling -M:Microsoft.CodeAnalysis.DllImportData.get_ModuleName -M:Microsoft.CodeAnalysis.DllImportData.get_SetLastError -M:Microsoft.CodeAnalysis.DllImportData.get_ThrowOnUnmappableCharacter -M:Microsoft.CodeAnalysis.DocumentationCommentId.CreateDeclarationId(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.DocumentationCommentId.CreateReferenceId(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.DocumentationCommentId.GetFirstSymbolForDeclarationId(System.String,Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.DocumentationCommentId.GetFirstSymbolForReferenceId(System.String,Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.DocumentationCommentId.GetSymbolsForDeclarationId(System.String,Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.DocumentationCommentId.GetSymbolsForReferenceId(System.String,Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.DocumentationProvider.#ctor -M:Microsoft.CodeAnalysis.DocumentationProvider.Equals(System.Object) -M:Microsoft.CodeAnalysis.DocumentationProvider.get_Default -M:Microsoft.CodeAnalysis.DocumentationProvider.GetDocumentationForSymbol(System.String,System.Globalization.CultureInfo,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.DocumentationProvider.GetHashCode -M:Microsoft.CodeAnalysis.EmbeddedText.FromBytes(System.String,System.ArraySegment{System.Byte},Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) -M:Microsoft.CodeAnalysis.EmbeddedText.FromSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.EmbeddedText.FromStream(System.String,System.IO.Stream,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) -M:Microsoft.CodeAnalysis.EmbeddedText.get_Checksum -M:Microsoft.CodeAnalysis.EmbeddedText.get_ChecksumAlgorithm -M:Microsoft.CodeAnalysis.EmbeddedText.get_FilePath -M:Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation.Create(System.Collections.Immutable.ImmutableArray{System.Byte},System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation.Create(System.Collections.Immutable.ImmutableArray{System.Byte},System.Collections.Immutable.ImmutableArray{System.Byte},System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.Emit.EmitBaseline.CreateInitialBaseline(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.ModuleMetadata,System.Func{System.Reflection.Metadata.MethodDefinitionHandle,Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation},System.Func{System.Reflection.Metadata.MethodDefinitionHandle,System.Reflection.Metadata.StandaloneSignatureHandle},System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitBaseline.CreateInitialBaseline(Microsoft.CodeAnalysis.ModuleMetadata,System.Func{System.Reflection.Metadata.MethodDefinitionHandle,Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation}) -M:Microsoft.CodeAnalysis.Emit.EmitBaseline.CreateInitialBaseline(Microsoft.CodeAnalysis.ModuleMetadata,System.Func{System.Reflection.Metadata.MethodDefinitionHandle,Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation},System.Func{System.Reflection.Metadata.MethodDefinitionHandle,System.Reflection.Metadata.StandaloneSignatureHandle},System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitBaseline.get_OriginalMetadata -M:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.get_Baseline -M:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.get_ChangedTypes -M:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.get_UpdatedMethods -M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind}) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind},System.Nullable{System.Security.Cryptography.HashAlgorithmName}) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.#ctor(System.Boolean,Microsoft.CodeAnalysis.Emit.DebugInformationFormat,System.String,System.String,System.Int32,System.UInt64,System.Boolean,Microsoft.CodeAnalysis.SubsystemVersion,System.String,System.Boolean,System.Boolean,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind},System.Nullable{System.Security.Cryptography.HashAlgorithmName},System.Text.Encoding,System.Text.Encoding) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.Equals(Microsoft.CodeAnalysis.Emit.EmitOptions) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.Equals(System.Object) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_BaseAddress -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_DebugInformationFormat -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_DefaultSourceFileEncoding -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_EmitMetadataOnly -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_FallbackSourceFileEncoding -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_FileAlignment -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_HighEntropyVirtualAddressSpace -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_IncludePrivateMembers -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_InstrumentationKinds -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_OutputNameOverride -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_PdbChecksumAlgorithm -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_PdbFilePath -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_RuntimeMetadataVersion -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_SubsystemVersion -M:Microsoft.CodeAnalysis.Emit.EmitOptions.get_TolerateErrors -M:Microsoft.CodeAnalysis.Emit.EmitOptions.GetHashCode -M:Microsoft.CodeAnalysis.Emit.EmitOptions.op_Equality(Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.Emit.EmitOptions) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.op_Inequality(Microsoft.CodeAnalysis.Emit.EmitOptions,Microsoft.CodeAnalysis.Emit.EmitOptions) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithBaseAddress(System.UInt64) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithDebugInformationFormat(Microsoft.CodeAnalysis.Emit.DebugInformationFormat) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithDefaultSourceFileEncoding(System.Text.Encoding) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithEmitMetadataOnly(System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithFallbackSourceFileEncoding(System.Text.Encoding) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithFileAlignment(System.Int32) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithHighEntropyVirtualAddressSpace(System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithIncludePrivateMembers(System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithInstrumentationKinds(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind}) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithOutputNameOverride(System.String) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithPdbChecksumAlgorithm(System.Security.Cryptography.HashAlgorithmName) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithPdbFilePath(System.String) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithRuntimeMetadataVersion(System.String) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithSubsystemVersion(Microsoft.CodeAnalysis.SubsystemVersion) -M:Microsoft.CodeAnalysis.Emit.EmitOptions.WithTolerateErrors(System.Boolean) -M:Microsoft.CodeAnalysis.Emit.EmitResult.get_Diagnostics -M:Microsoft.CodeAnalysis.Emit.EmitResult.get_Success -M:Microsoft.CodeAnalysis.Emit.EmitResult.GetDebuggerDisplay -M:Microsoft.CodeAnalysis.Emit.MethodInstrumentation.get_Kinds -M:Microsoft.CodeAnalysis.Emit.MethodInstrumentation.set_Kinds(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Emit.InstrumentationKind}) -M:Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit.#ctor(System.String) -M:Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit.get_Message -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.#ctor(Microsoft.CodeAnalysis.Emit.SemanticEditKind,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.#ctor(Microsoft.CodeAnalysis.Emit.SemanticEditKind,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Boolean,Microsoft.CodeAnalysis.Emit.MethodInstrumentation) -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.#ctor(Microsoft.CodeAnalysis.Emit.SemanticEditKind,Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol,System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Nullable{Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit}},Microsoft.CodeAnalysis.Emit.MethodInstrumentation) -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.Equals(Microsoft.CodeAnalysis.Emit.SemanticEdit) -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.Equals(System.Object) -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_Instrumentation -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_Kind -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_NewSymbol -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_OldSymbol -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_PreserveLocalVariables -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_RuntimeRudeEdit -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.get_SyntaxMap -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.GetHashCode -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.op_Equality(Microsoft.CodeAnalysis.Emit.SemanticEdit,Microsoft.CodeAnalysis.Emit.SemanticEdit) -M:Microsoft.CodeAnalysis.Emit.SemanticEdit.op_Inequality(Microsoft.CodeAnalysis.Emit.SemanticEdit,Microsoft.CodeAnalysis.Emit.SemanticEdit) -M:Microsoft.CodeAnalysis.ErrorLogOptions.#ctor(System.String,Microsoft.CodeAnalysis.SarifVersion) -M:Microsoft.CodeAnalysis.ErrorLogOptions.get_Path -M:Microsoft.CodeAnalysis.ErrorLogOptions.get_SarifVersion -M:Microsoft.CodeAnalysis.FileLinePositionSpan.#ctor(System.String,Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.FileLinePositionSpan.#ctor(System.String,Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.FileLinePositionSpan.Equals(Microsoft.CodeAnalysis.FileLinePositionSpan) -M:Microsoft.CodeAnalysis.FileLinePositionSpan.Equals(System.Object) -M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_EndLinePosition -M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_HasMappedPath -M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_IsValid -M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_Path -M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_Span -M:Microsoft.CodeAnalysis.FileLinePositionSpan.get_StartLinePosition -M:Microsoft.CodeAnalysis.FileLinePositionSpan.GetHashCode -M:Microsoft.CodeAnalysis.FileLinePositionSpan.op_Equality(Microsoft.CodeAnalysis.FileLinePositionSpan,Microsoft.CodeAnalysis.FileLinePositionSpan) -M:Microsoft.CodeAnalysis.FileLinePositionSpan.op_Inequality(Microsoft.CodeAnalysis.FileLinePositionSpan,Microsoft.CodeAnalysis.FileLinePositionSpan) -M:Microsoft.CodeAnalysis.FileLinePositionSpan.ToString -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_BranchValue -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_ConditionalSuccessor -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_ConditionKind -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_EnclosingRegion -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_FallThroughSuccessor -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_IsReachable -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Kind -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Operations -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Ordinal -M:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock.get_Predecessors -M:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.Equals(Microsoft.CodeAnalysis.FlowAnalysis.CaptureId) -M:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.Equals(System.Object) -M:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId.GetHashCode -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Destination -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_EnteringRegions -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_FinallyRegions -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_IsConditionalSuccessor -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_LeavingRegions -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Semantics -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch.get_Source -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IAttributeOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IBlockOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.Create(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Blocks -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_LocalFunctions -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_OriginalOperation -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Parent -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.get_Root -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.GetAnonymousFunctionControlFlowGraph(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph.GetLocalFunctionControlFlowGraph(Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions.GetAnonymousFunctionControlFlowGraphInScope(Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph,Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions.GetLocalFunctionControlFlowGraphInScope(Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph,Microsoft.CodeAnalysis.IMethodSymbol,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_CaptureIds -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_EnclosingRegion -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_ExceptionType -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_FirstBlockOrdinal -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_Kind -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_LastBlockOrdinal -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_LocalFunctions -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_Locals -M:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion.get_NestedRegions -M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation.get_Symbol -M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation.get_Id -M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation.get_Value -M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation.get_Id -M:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation.get_IsInitialization -M:Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation.get_Operand -M:Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation.get_Local -M:Microsoft.CodeAnalysis.GeneratedSourceResult.get_HintName -M:Microsoft.CodeAnalysis.GeneratedSourceResult.get_SourceText -M:Microsoft.CodeAnalysis.GeneratedSourceResult.get_SyntaxTree -M:Microsoft.CodeAnalysis.GeneratorAttribute.#ctor -M:Microsoft.CodeAnalysis.GeneratorAttribute.#ctor(System.String,System.String[]) -M:Microsoft.CodeAnalysis.GeneratorAttribute.get_Languages -M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_Attributes -M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_SemanticModel -M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_TargetNode -M:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext.get_TargetSymbol -M:Microsoft.CodeAnalysis.GeneratorDriver.AddAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) -M:Microsoft.CodeAnalysis.GeneratorDriver.AddGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) -M:Microsoft.CodeAnalysis.GeneratorDriver.GetRunResult -M:Microsoft.CodeAnalysis.GeneratorDriver.GetTimingInfo -M:Microsoft.CodeAnalysis.GeneratorDriver.RemoveAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) -M:Microsoft.CodeAnalysis.GeneratorDriver.RemoveGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) -M:Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalText(Microsoft.CodeAnalysis.AdditionalText,Microsoft.CodeAnalysis.AdditionalText) -M:Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalTexts(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.AdditionalText}) -M:Microsoft.CodeAnalysis.GeneratorDriver.ReplaceGenerators(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISourceGenerator}) -M:Microsoft.CodeAnalysis.GeneratorDriver.RunGenerators(Microsoft.CodeAnalysis.Compilation,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.GeneratorDriver.RunGeneratorsAndUpdateCompilation(Microsoft.CodeAnalysis.Compilation,Microsoft.CodeAnalysis.Compilation@,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Diagnostic}@,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedAnalyzerConfigOptions(Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider) -M:Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedParseOptions(Microsoft.CodeAnalysis.ParseOptions) -M:Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind) -M:Microsoft.CodeAnalysis.GeneratorDriverOptions.#ctor(Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind,System.Boolean) -M:Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_Diagnostics -M:Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_GeneratedTrees -M:Microsoft.CodeAnalysis.GeneratorDriverRunResult.get_Results -M:Microsoft.CodeAnalysis.GeneratorDriverTimingInfo.get_ElapsedTime -M:Microsoft.CodeAnalysis.GeneratorDriverTimingInfo.get_GeneratorTimes -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.AddSource(System.String,System.String) -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_AdditionalFiles -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_AnalyzerConfigOptions -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_CancellationToken -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_Compilation -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_ParseOptions -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_SyntaxContextReceiver -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.get_SyntaxReceiver -M:Microsoft.CodeAnalysis.GeneratorExecutionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.GeneratorExtensions.AsSourceGenerator(Microsoft.CodeAnalysis.IIncrementalGenerator) -M:Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(Microsoft.CodeAnalysis.ISourceGenerator) -M:Microsoft.CodeAnalysis.GeneratorInitializationContext.get_CancellationToken -M:Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForPostInitialization(System.Action{Microsoft.CodeAnalysis.GeneratorPostInitializationContext}) -M:Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxContextReceiverCreator) -M:Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxReceiverCreator) -M:Microsoft.CodeAnalysis.GeneratorPostInitializationContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.GeneratorPostInitializationContext.AddSource(System.String,System.String) -M:Microsoft.CodeAnalysis.GeneratorPostInitializationContext.get_CancellationToken -M:Microsoft.CodeAnalysis.GeneratorRunResult.get_Diagnostics -M:Microsoft.CodeAnalysis.GeneratorRunResult.get_Exception -M:Microsoft.CodeAnalysis.GeneratorRunResult.get_GeneratedSources -M:Microsoft.CodeAnalysis.GeneratorRunResult.get_Generator -M:Microsoft.CodeAnalysis.GeneratorRunResult.get_TrackedOutputSteps -M:Microsoft.CodeAnalysis.GeneratorRunResult.get_TrackedSteps -M:Microsoft.CodeAnalysis.GeneratorSyntaxContext.get_Node -M:Microsoft.CodeAnalysis.GeneratorSyntaxContext.get_SemanticModel -M:Microsoft.CodeAnalysis.GeneratorTimingInfo.get_ElapsedTime -M:Microsoft.CodeAnalysis.GeneratorTimingInfo.get_Generator -M:Microsoft.CodeAnalysis.IAliasSymbol.get_Target -M:Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader.AddDependencyLocation(System.String) -M:Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader.LoadFromPath(System.String) -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.Equals(Microsoft.CodeAnalysis.IArrayTypeSymbol) -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_CustomModifiers -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_ElementNullableAnnotation -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_ElementType -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_IsSZArray -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_LowerBounds -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_Rank -M:Microsoft.CodeAnalysis.IArrayTypeSymbol.get_Sizes -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_GlobalNamespace -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_Identity -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_IsInteractive -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_MightContainExtensionMethods -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_Modules -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_NamespaceNames -M:Microsoft.CodeAnalysis.IAssemblySymbol.get_TypeNames -M:Microsoft.CodeAnalysis.IAssemblySymbol.GetForwardedTypes -M:Microsoft.CodeAnalysis.IAssemblySymbol.GetMetadata -M:Microsoft.CodeAnalysis.IAssemblySymbol.GetTypeByMetadataName(System.String) -M:Microsoft.CodeAnalysis.IAssemblySymbol.GivesAccessTo(Microsoft.CodeAnalysis.IAssemblySymbol) -M:Microsoft.CodeAnalysis.IAssemblySymbol.ResolveForwardedType(System.String) -M:Microsoft.CodeAnalysis.ICompilationUnitSyntax.get_EndOfFileToken -M:Microsoft.CodeAnalysis.IDiscardSymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.IDiscardSymbol.get_Type -M:Microsoft.CodeAnalysis.IErrorTypeSymbol.get_CandidateReason -M:Microsoft.CodeAnalysis.IErrorTypeSymbol.get_CandidateSymbols -M:Microsoft.CodeAnalysis.IEventSymbol.get_AddMethod -M:Microsoft.CodeAnalysis.IEventSymbol.get_ExplicitInterfaceImplementations -M:Microsoft.CodeAnalysis.IEventSymbol.get_IsWindowsRuntimeEvent -M:Microsoft.CodeAnalysis.IEventSymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.IEventSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.IEventSymbol.get_OverriddenEvent -M:Microsoft.CodeAnalysis.IEventSymbol.get_RaiseMethod -M:Microsoft.CodeAnalysis.IEventSymbol.get_RemoveMethod -M:Microsoft.CodeAnalysis.IEventSymbol.get_Type -M:Microsoft.CodeAnalysis.IFieldSymbol.get_AssociatedSymbol -M:Microsoft.CodeAnalysis.IFieldSymbol.get_ConstantValue -M:Microsoft.CodeAnalysis.IFieldSymbol.get_CorrespondingTupleField -M:Microsoft.CodeAnalysis.IFieldSymbol.get_CustomModifiers -M:Microsoft.CodeAnalysis.IFieldSymbol.get_FixedSize -M:Microsoft.CodeAnalysis.IFieldSymbol.get_HasConstantValue -M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsConst -M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsExplicitlyNamedTupleElement -M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsFixedSizeBuffer -M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsReadOnly -M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsRequired -M:Microsoft.CodeAnalysis.IFieldSymbol.get_IsVolatile -M:Microsoft.CodeAnalysis.IFieldSymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.IFieldSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.IFieldSymbol.get_RefCustomModifiers -M:Microsoft.CodeAnalysis.IFieldSymbol.get_RefKind -M:Microsoft.CodeAnalysis.IFieldSymbol.get_Type -M:Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol.get_Signature -M:Microsoft.CodeAnalysis.IImportScope.get_Aliases -M:Microsoft.CodeAnalysis.IImportScope.get_ExternAliases -M:Microsoft.CodeAnalysis.IImportScope.get_Imports -M:Microsoft.CodeAnalysis.IImportScope.get_XmlNamespaces -M:Microsoft.CodeAnalysis.IIncrementalGenerator.Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext) -M:Microsoft.CodeAnalysis.ILabelSymbol.get_ContainingMethod -M:Microsoft.CodeAnalysis.ILocalSymbol.get_ConstantValue -M:Microsoft.CodeAnalysis.ILocalSymbol.get_HasConstantValue -M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsConst -M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsFixed -M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsForEach -M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsFunctionValue -M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsRef -M:Microsoft.CodeAnalysis.ILocalSymbol.get_IsUsing -M:Microsoft.CodeAnalysis.ILocalSymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.ILocalSymbol.get_RefKind -M:Microsoft.CodeAnalysis.ILocalSymbol.get_ScopedKind -M:Microsoft.CodeAnalysis.ILocalSymbol.get_Type -M:Microsoft.CodeAnalysis.IMethodSymbol.Construct(Microsoft.CodeAnalysis.ITypeSymbol[]) -M:Microsoft.CodeAnalysis.IMethodSymbol.Construct(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.IMethodSymbol.get_Arity -M:Microsoft.CodeAnalysis.IMethodSymbol.get_AssociatedAnonymousDelegate -M:Microsoft.CodeAnalysis.IMethodSymbol.get_AssociatedSymbol -M:Microsoft.CodeAnalysis.IMethodSymbol.get_CallingConvention -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ConstructedFrom -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ExplicitInterfaceImplementations -M:Microsoft.CodeAnalysis.IMethodSymbol.get_HidesBaseMethodsByName -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsAsync -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsCheckedBuiltin -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsConditional -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsExtensionMethod -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsGenericMethod -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsInitOnly -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsPartialDefinition -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsReadOnly -M:Microsoft.CodeAnalysis.IMethodSymbol.get_IsVararg -M:Microsoft.CodeAnalysis.IMethodSymbol.get_MethodImplementationFlags -M:Microsoft.CodeAnalysis.IMethodSymbol.get_MethodKind -M:Microsoft.CodeAnalysis.IMethodSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.IMethodSymbol.get_OverriddenMethod -M:Microsoft.CodeAnalysis.IMethodSymbol.get_Parameters -M:Microsoft.CodeAnalysis.IMethodSymbol.get_PartialDefinitionPart -M:Microsoft.CodeAnalysis.IMethodSymbol.get_PartialImplementationPart -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReceiverNullableAnnotation -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReceiverType -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReducedFrom -M:Microsoft.CodeAnalysis.IMethodSymbol.get_RefCustomModifiers -M:Microsoft.CodeAnalysis.IMethodSymbol.get_RefKind -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnNullableAnnotation -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsByRef -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsByRefReadonly -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnsVoid -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnType -M:Microsoft.CodeAnalysis.IMethodSymbol.get_ReturnTypeCustomModifiers -M:Microsoft.CodeAnalysis.IMethodSymbol.get_TypeArgumentNullableAnnotations -M:Microsoft.CodeAnalysis.IMethodSymbol.get_TypeArguments -M:Microsoft.CodeAnalysis.IMethodSymbol.get_TypeParameters -M:Microsoft.CodeAnalysis.IMethodSymbol.get_UnmanagedCallingConventionTypes -M:Microsoft.CodeAnalysis.IMethodSymbol.GetDllImportData -M:Microsoft.CodeAnalysis.IMethodSymbol.GetReturnTypeAttributes -M:Microsoft.CodeAnalysis.IMethodSymbol.GetTypeInferredDuringReduction(Microsoft.CodeAnalysis.ITypeParameterSymbol) -M:Microsoft.CodeAnalysis.IMethodSymbol.ReduceExtensionMethod(Microsoft.CodeAnalysis.ITypeSymbol) -M:Microsoft.CodeAnalysis.IModuleSymbol.get_GlobalNamespace -M:Microsoft.CodeAnalysis.IModuleSymbol.get_ReferencedAssemblies -M:Microsoft.CodeAnalysis.IModuleSymbol.get_ReferencedAssemblySymbols -M:Microsoft.CodeAnalysis.IModuleSymbol.GetMetadata -M:Microsoft.CodeAnalysis.IModuleSymbol.GetModuleNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) -M:Microsoft.CodeAnalysis.ImportedNamespaceOrType.get_DeclaringSyntaxReference -M:Microsoft.CodeAnalysis.ImportedNamespaceOrType.get_NamespaceOrType -M:Microsoft.CodeAnalysis.ImportedXmlNamespace.get_DeclaringSyntaxReference -M:Microsoft.CodeAnalysis.ImportedXmlNamespace.get_XmlNamespace -M:Microsoft.CodeAnalysis.INamedTypeSymbol.Construct(Microsoft.CodeAnalysis.ITypeSymbol[]) -M:Microsoft.CodeAnalysis.INamedTypeSymbol.Construct(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ITypeSymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.NullableAnnotation}) -M:Microsoft.CodeAnalysis.INamedTypeSymbol.ConstructUnboundGenericType -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_Arity -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_AssociatedSymbol -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_ConstructedFrom -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_Constructors -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_DelegateInvokeMethod -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_EnumUnderlyingType -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_InstanceConstructors -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsComImport -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsFileLocal -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsGenericType -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsImplicitClass -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsScriptClass -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsSerializable -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_IsUnboundGenericType -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_MemberNames -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_MightContainExtensionMethods -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_NativeIntegerUnderlyingType -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_StaticConstructors -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TupleElements -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TupleUnderlyingType -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeArgumentNullableAnnotations -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeArguments -M:Microsoft.CodeAnalysis.INamedTypeSymbol.get_TypeParameters -M:Microsoft.CodeAnalysis.INamedTypeSymbol.GetTypeArgumentCustomModifiers(System.Int32) -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.get_IsNamespace -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.get_IsType -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetMembers -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetMembers(System.String) -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers(System.String) -M:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol.GetTypeMembers(System.String,System.Int32) -M:Microsoft.CodeAnalysis.INamespaceSymbol.get_ConstituentNamespaces -M:Microsoft.CodeAnalysis.INamespaceSymbol.get_ContainingCompilation -M:Microsoft.CodeAnalysis.INamespaceSymbol.get_IsGlobalNamespace -M:Microsoft.CodeAnalysis.INamespaceSymbol.get_NamespaceKind -M:Microsoft.CodeAnalysis.INamespaceSymbol.GetMembers -M:Microsoft.CodeAnalysis.INamespaceSymbol.GetMembers(System.String) -M:Microsoft.CodeAnalysis.INamespaceSymbol.GetNamespaceMembers -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_AdditionalTextsProvider -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_AnalyzerConfigOptionsProvider -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_CompilationProvider -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_MetadataReferencesProvider -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_ParseOptionsProvider -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.get_SyntaxProvider -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterPostInitializationOutput(System.Action{Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext}) -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) -M:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Action{Microsoft.CodeAnalysis.SourceProductionContext,``0}) -M:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(System.String,System.String) -M:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.get_CancellationToken -M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_ElapsedTime -M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Inputs -M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Name -M:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep.get_Outputs -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Collect``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},Microsoft.CodeAnalysis.IncrementalValueProvider{``1}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},Microsoft.CodeAnalysis.IncrementalValueProvider{``1}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,``1}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,``1}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Generic.IEnumerable{``1}}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Immutable.ImmutableArray{``1}}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Generic.IEnumerable{``1}}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany``2(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Threading.CancellationToken,System.Collections.Immutable.ImmutableArray{``1}}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Where``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Func{``0,System.Boolean}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithTrackingName``1(Microsoft.CodeAnalysis.IncrementalValueProvider{``0},System.String) -M:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithTrackingName``1(Microsoft.CodeAnalysis.IncrementalValuesProvider{``0},System.String) -M:Microsoft.CodeAnalysis.IOperation.Accept(Microsoft.CodeAnalysis.Operations.OperationVisitor) -M:Microsoft.CodeAnalysis.IOperation.Accept``2(Microsoft.CodeAnalysis.Operations.OperationVisitor{``0,``1},``0) -M:Microsoft.CodeAnalysis.IOperation.get_ChildOperations -M:Microsoft.CodeAnalysis.IOperation.get_Children -M:Microsoft.CodeAnalysis.IOperation.get_ConstantValue -M:Microsoft.CodeAnalysis.IOperation.get_IsImplicit -M:Microsoft.CodeAnalysis.IOperation.get_Kind -M:Microsoft.CodeAnalysis.IOperation.get_Language -M:Microsoft.CodeAnalysis.IOperation.get_Parent -M:Microsoft.CodeAnalysis.IOperation.get_SemanticModel -M:Microsoft.CodeAnalysis.IOperation.get_Syntax -M:Microsoft.CodeAnalysis.IOperation.get_Type -M:Microsoft.CodeAnalysis.IOperation.OperationList.Any -M:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.get_Current -M:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.Reset -M:Microsoft.CodeAnalysis.IOperation.OperationList.First -M:Microsoft.CodeAnalysis.IOperation.OperationList.get_Count -M:Microsoft.CodeAnalysis.IOperation.OperationList.GetEnumerator -M:Microsoft.CodeAnalysis.IOperation.OperationList.Last -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reverse -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.get_Current -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.Reset -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.get_Count -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.GetEnumerator -M:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.ToImmutableArray -M:Microsoft.CodeAnalysis.IOperation.OperationList.ToImmutableArray -M:Microsoft.CodeAnalysis.IParameterSymbol.get_CustomModifiers -M:Microsoft.CodeAnalysis.IParameterSymbol.get_ExplicitDefaultValue -M:Microsoft.CodeAnalysis.IParameterSymbol.get_HasExplicitDefaultValue -M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsDiscard -M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsOptional -M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsParams -M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsParamsArray -M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsParamsCollection -M:Microsoft.CodeAnalysis.IParameterSymbol.get_IsThis -M:Microsoft.CodeAnalysis.IParameterSymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.IParameterSymbol.get_Ordinal -M:Microsoft.CodeAnalysis.IParameterSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.IParameterSymbol.get_RefCustomModifiers -M:Microsoft.CodeAnalysis.IParameterSymbol.get_RefKind -M:Microsoft.CodeAnalysis.IParameterSymbol.get_ScopedKind -M:Microsoft.CodeAnalysis.IParameterSymbol.get_Type -M:Microsoft.CodeAnalysis.IPointerTypeSymbol.get_CustomModifiers -M:Microsoft.CodeAnalysis.IPointerTypeSymbol.get_PointedAtType -M:Microsoft.CodeAnalysis.IPropertySymbol.get_ExplicitInterfaceImplementations -M:Microsoft.CodeAnalysis.IPropertySymbol.get_GetMethod -M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsIndexer -M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsPartialDefinition -M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsReadOnly -M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsRequired -M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsWithEvents -M:Microsoft.CodeAnalysis.IPropertySymbol.get_IsWriteOnly -M:Microsoft.CodeAnalysis.IPropertySymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.IPropertySymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.IPropertySymbol.get_OverriddenProperty -M:Microsoft.CodeAnalysis.IPropertySymbol.get_Parameters -M:Microsoft.CodeAnalysis.IPropertySymbol.get_PartialDefinitionPart -M:Microsoft.CodeAnalysis.IPropertySymbol.get_PartialImplementationPart -M:Microsoft.CodeAnalysis.IPropertySymbol.get_RefCustomModifiers -M:Microsoft.CodeAnalysis.IPropertySymbol.get_RefKind -M:Microsoft.CodeAnalysis.IPropertySymbol.get_ReturnsByRef -M:Microsoft.CodeAnalysis.IPropertySymbol.get_ReturnsByRefReadonly -M:Microsoft.CodeAnalysis.IPropertySymbol.get_SetMethod -M:Microsoft.CodeAnalysis.IPropertySymbol.get_Type -M:Microsoft.CodeAnalysis.IPropertySymbol.get_TypeCustomModifiers -M:Microsoft.CodeAnalysis.ISkippedTokensTriviaSyntax.get_Tokens -M:Microsoft.CodeAnalysis.ISourceAssemblySymbol.get_Compilation -M:Microsoft.CodeAnalysis.ISourceGenerator.Execute(Microsoft.CodeAnalysis.GeneratorExecutionContext) -M:Microsoft.CodeAnalysis.ISourceGenerator.Initialize(Microsoft.CodeAnalysis.GeneratorInitializationContext) -M:Microsoft.CodeAnalysis.IStructuredTriviaSyntax.get_ParentTrivia -M:Microsoft.CodeAnalysis.ISymbol.Accept(Microsoft.CodeAnalysis.SymbolVisitor) -M:Microsoft.CodeAnalysis.ISymbol.Accept``1(Microsoft.CodeAnalysis.SymbolVisitor{``0}) -M:Microsoft.CodeAnalysis.ISymbol.Accept``2(Microsoft.CodeAnalysis.SymbolVisitor{``0,``1},``0) -M:Microsoft.CodeAnalysis.ISymbol.Equals(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SymbolEqualityComparer) -M:Microsoft.CodeAnalysis.ISymbol.get_CanBeReferencedByName -M:Microsoft.CodeAnalysis.ISymbol.get_ContainingAssembly -M:Microsoft.CodeAnalysis.ISymbol.get_ContainingModule -M:Microsoft.CodeAnalysis.ISymbol.get_ContainingNamespace -M:Microsoft.CodeAnalysis.ISymbol.get_ContainingSymbol -M:Microsoft.CodeAnalysis.ISymbol.get_ContainingType -M:Microsoft.CodeAnalysis.ISymbol.get_DeclaredAccessibility -M:Microsoft.CodeAnalysis.ISymbol.get_DeclaringSyntaxReferences -M:Microsoft.CodeAnalysis.ISymbol.get_HasUnsupportedMetadata -M:Microsoft.CodeAnalysis.ISymbol.get_IsAbstract -M:Microsoft.CodeAnalysis.ISymbol.get_IsDefinition -M:Microsoft.CodeAnalysis.ISymbol.get_IsExtern -M:Microsoft.CodeAnalysis.ISymbol.get_IsImplicitlyDeclared -M:Microsoft.CodeAnalysis.ISymbol.get_IsOverride -M:Microsoft.CodeAnalysis.ISymbol.get_IsSealed -M:Microsoft.CodeAnalysis.ISymbol.get_IsStatic -M:Microsoft.CodeAnalysis.ISymbol.get_IsVirtual -M:Microsoft.CodeAnalysis.ISymbol.get_Kind -M:Microsoft.CodeAnalysis.ISymbol.get_Language -M:Microsoft.CodeAnalysis.ISymbol.get_Locations -M:Microsoft.CodeAnalysis.ISymbol.get_MetadataName -M:Microsoft.CodeAnalysis.ISymbol.get_MetadataToken -M:Microsoft.CodeAnalysis.ISymbol.get_Name -M:Microsoft.CodeAnalysis.ISymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.ISymbol.GetAttributes -M:Microsoft.CodeAnalysis.ISymbol.GetDocumentationCommentId -M:Microsoft.CodeAnalysis.ISymbol.GetDocumentationCommentXml(System.Globalization.CultureInfo,System.Boolean,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.ISymbol.ToDisplayParts(Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ISymbol.ToDisplayString(Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ISymbol.ToMinimalDisplayParts(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ISymbol.ToMinimalDisplayString(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ISymbolExtensions.GetConstructedReducedFrom(Microsoft.CodeAnalysis.IMethodSymbol) -M:Microsoft.CodeAnalysis.ISyntaxContextReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.GeneratorSyntaxContext) -M:Microsoft.CodeAnalysis.ISyntaxReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_AllowsRefLikeType -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ConstraintNullableAnnotations -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ConstraintTypes -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_DeclaringMethod -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_DeclaringType -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasConstructorConstraint -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasNotNullConstraint -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasReferenceTypeConstraint -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasUnmanagedTypeConstraint -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_HasValueTypeConstraint -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_Ordinal -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ReducedFrom -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_ReferenceTypeConstraintNullableAnnotation -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_TypeParameterKind -M:Microsoft.CodeAnalysis.ITypeParameterSymbol.get_Variance -M:Microsoft.CodeAnalysis.ITypeSymbol.FindImplementationForInterfaceMember(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.ITypeSymbol.get_AllInterfaces -M:Microsoft.CodeAnalysis.ITypeSymbol.get_BaseType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_Interfaces -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsAnonymousType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsNativeIntegerType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsReadOnly -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsRecord -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsReferenceType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsRefLikeType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsTupleType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsUnmanagedType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_IsValueType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_NullableAnnotation -M:Microsoft.CodeAnalysis.ITypeSymbol.get_OriginalDefinition -M:Microsoft.CodeAnalysis.ITypeSymbol.get_SpecialType -M:Microsoft.CodeAnalysis.ITypeSymbol.get_TypeKind -M:Microsoft.CodeAnalysis.ITypeSymbol.ToDisplayParts(Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ITypeSymbol.ToDisplayString(Microsoft.CodeAnalysis.NullableFlowState,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ITypeSymbol.ToMinimalDisplayParts(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.NullableFlowState,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ITypeSymbol.ToMinimalDisplayString(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.NullableFlowState,System.Int32,Microsoft.CodeAnalysis.SymbolDisplayFormat) -M:Microsoft.CodeAnalysis.ITypeSymbol.WithNullableAnnotation(Microsoft.CodeAnalysis.NullableAnnotation) -M:Microsoft.CodeAnalysis.LineMapping.#ctor(Microsoft.CodeAnalysis.Text.LinePositionSpan,System.Nullable{System.Int32},Microsoft.CodeAnalysis.FileLinePositionSpan) -M:Microsoft.CodeAnalysis.LineMapping.Equals(Microsoft.CodeAnalysis.LineMapping) -M:Microsoft.CodeAnalysis.LineMapping.Equals(System.Object) -M:Microsoft.CodeAnalysis.LineMapping.get_CharacterOffset -M:Microsoft.CodeAnalysis.LineMapping.get_IsHidden -M:Microsoft.CodeAnalysis.LineMapping.get_MappedSpan -M:Microsoft.CodeAnalysis.LineMapping.get_Span -M:Microsoft.CodeAnalysis.LineMapping.GetHashCode -M:Microsoft.CodeAnalysis.LineMapping.op_Equality(Microsoft.CodeAnalysis.LineMapping,Microsoft.CodeAnalysis.LineMapping) -M:Microsoft.CodeAnalysis.LineMapping.op_Inequality(Microsoft.CodeAnalysis.LineMapping,Microsoft.CodeAnalysis.LineMapping) -M:Microsoft.CodeAnalysis.LineMapping.ToString -M:Microsoft.CodeAnalysis.LocalizableResourceString.#ctor(System.String,System.Resources.ResourceManager,System.Type) -M:Microsoft.CodeAnalysis.LocalizableResourceString.#ctor(System.String,System.Resources.ResourceManager,System.Type,System.String[]) -M:Microsoft.CodeAnalysis.LocalizableResourceString.AreEqual(System.Object) -M:Microsoft.CodeAnalysis.LocalizableResourceString.GetHash -M:Microsoft.CodeAnalysis.LocalizableResourceString.GetText(System.IFormatProvider) -M:Microsoft.CodeAnalysis.LocalizableString.#ctor -M:Microsoft.CodeAnalysis.LocalizableString.add_OnException(System.EventHandler{System.Exception}) -M:Microsoft.CodeAnalysis.LocalizableString.AreEqual(System.Object) -M:Microsoft.CodeAnalysis.LocalizableString.Equals(Microsoft.CodeAnalysis.LocalizableString) -M:Microsoft.CodeAnalysis.LocalizableString.Equals(System.Object) -M:Microsoft.CodeAnalysis.LocalizableString.GetHash -M:Microsoft.CodeAnalysis.LocalizableString.GetHashCode -M:Microsoft.CodeAnalysis.LocalizableString.GetText(System.IFormatProvider) -M:Microsoft.CodeAnalysis.LocalizableString.op_Explicit(Microsoft.CodeAnalysis.LocalizableString)~System.String -M:Microsoft.CodeAnalysis.LocalizableString.op_Implicit(System.String)~Microsoft.CodeAnalysis.LocalizableString -M:Microsoft.CodeAnalysis.LocalizableString.remove_OnException(System.EventHandler{System.Exception}) -M:Microsoft.CodeAnalysis.LocalizableString.ToString -M:Microsoft.CodeAnalysis.LocalizableString.ToString(System.IFormatProvider) -M:Microsoft.CodeAnalysis.Location.Create(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Location.Create(System.String,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.Location.Create(System.String,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan,System.String,Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.Location.Equals(System.Object) -M:Microsoft.CodeAnalysis.Location.get_IsInMetadata -M:Microsoft.CodeAnalysis.Location.get_IsInSource -M:Microsoft.CodeAnalysis.Location.get_Kind -M:Microsoft.CodeAnalysis.Location.get_MetadataModule -M:Microsoft.CodeAnalysis.Location.get_None -M:Microsoft.CodeAnalysis.Location.get_SourceSpan -M:Microsoft.CodeAnalysis.Location.get_SourceTree -M:Microsoft.CodeAnalysis.Location.GetDebuggerDisplay -M:Microsoft.CodeAnalysis.Location.GetHashCode -M:Microsoft.CodeAnalysis.Location.GetLineSpan -M:Microsoft.CodeAnalysis.Location.GetMappedLineSpan -M:Microsoft.CodeAnalysis.Location.op_Equality(Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.Location) -M:Microsoft.CodeAnalysis.Location.op_Inequality(Microsoft.CodeAnalysis.Location,Microsoft.CodeAnalysis.Location) -M:Microsoft.CodeAnalysis.Location.ToString -M:Microsoft.CodeAnalysis.Metadata.CommonCopy -M:Microsoft.CodeAnalysis.Metadata.Copy -M:Microsoft.CodeAnalysis.Metadata.Dispose -M:Microsoft.CodeAnalysis.Metadata.get_Id -M:Microsoft.CodeAnalysis.Metadata.get_Kind -M:Microsoft.CodeAnalysis.MetadataReference.#ctor(Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.MetadataReference.CreateFromAssembly(System.Reflection.Assembly) -M:Microsoft.CodeAnalysis.MetadataReference.CreateFromAssembly(System.Reflection.Assembly,Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider) -M:Microsoft.CodeAnalysis.MetadataReference.CreateFromImage(System.Collections.Generic.IEnumerable{System.Byte},Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider,System.String) -M:Microsoft.CodeAnalysis.MetadataReference.CreateFromImage(System.Collections.Immutable.ImmutableArray{System.Byte},Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider,System.String) -M:Microsoft.CodeAnalysis.MetadataReference.CreateFromStream(System.IO.Stream,Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.DocumentationProvider,System.String) -M:Microsoft.CodeAnalysis.MetadataReference.get_Display -M:Microsoft.CodeAnalysis.MetadataReference.get_Properties -M:Microsoft.CodeAnalysis.MetadataReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.MetadataReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.MetadataReference.WithEmbedInteropTypes(System.Boolean) -M:Microsoft.CodeAnalysis.MetadataReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.#ctor(Microsoft.CodeAnalysis.MetadataImageKind,System.Collections.Immutable.ImmutableArray{System.String},System.Boolean) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.Equals(Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.Equals(System.Object) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Aliases -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Assembly -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_EmbedInteropTypes -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_GlobalAlias -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Kind -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.get_Module -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.GetHashCode -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.op_Equality(Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.op_Inequality(Microsoft.CodeAnalysis.MetadataReferenceProperties,Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.WithAliases(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.MetadataReferenceProperties.WithEmbedInteropTypes(System.Boolean) -M:Microsoft.CodeAnalysis.MetadataReferenceResolver.#ctor -M:Microsoft.CodeAnalysis.MetadataReferenceResolver.Equals(System.Object) -M:Microsoft.CodeAnalysis.MetadataReferenceResolver.get_ResolveMissingAssemblies -M:Microsoft.CodeAnalysis.MetadataReferenceResolver.GetHashCode -M:Microsoft.CodeAnalysis.MetadataReferenceResolver.ResolveMissingAssembly(Microsoft.CodeAnalysis.MetadataReference,Microsoft.CodeAnalysis.AssemblyIdentity) -M:Microsoft.CodeAnalysis.MetadataReferenceResolver.ResolveReference(System.String,System.String,Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeControlFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.ModelExtensions.GetAliasInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.ModelExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.ModelExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeAliasInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.ModelExtensions.GetSpeculativeTypeInfo(Microsoft.CodeAnalysis.SemanticModel,System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.ModelExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.ModelExtensions.GetTypeInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.ModuleMetadata.CommonCopy -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromFile(System.String) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromImage(System.Collections.Generic.IEnumerable{System.Byte}) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromImage(System.Collections.Immutable.ImmutableArray{System.Byte}) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromImage(System.IntPtr,System.Int32) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromMetadata(System.IntPtr,System.Int32) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromMetadata(System.IntPtr,System.Int32,System.Action) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromStream(System.IO.Stream,System.Boolean) -M:Microsoft.CodeAnalysis.ModuleMetadata.CreateFromStream(System.IO.Stream,System.Reflection.PortableExecutable.PEStreamOptions) -M:Microsoft.CodeAnalysis.ModuleMetadata.Dispose -M:Microsoft.CodeAnalysis.ModuleMetadata.get_IsDisposed -M:Microsoft.CodeAnalysis.ModuleMetadata.get_Kind -M:Microsoft.CodeAnalysis.ModuleMetadata.get_Name -M:Microsoft.CodeAnalysis.ModuleMetadata.GetMetadataReader -M:Microsoft.CodeAnalysis.ModuleMetadata.GetModuleNames -M:Microsoft.CodeAnalysis.ModuleMetadata.GetModuleVersionId -M:Microsoft.CodeAnalysis.ModuleMetadata.GetReference(Microsoft.CodeAnalysis.DocumentationProvider,System.String,System.String) -M:Microsoft.CodeAnalysis.NullabilityInfo.Equals(Microsoft.CodeAnalysis.NullabilityInfo) -M:Microsoft.CodeAnalysis.NullabilityInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.NullabilityInfo.get_Annotation -M:Microsoft.CodeAnalysis.NullabilityInfo.get_FlowState -M:Microsoft.CodeAnalysis.NullabilityInfo.GetHashCode -M:Microsoft.CodeAnalysis.NullableContextExtensions.AnnotationsEnabled(Microsoft.CodeAnalysis.NullableContext) -M:Microsoft.CodeAnalysis.NullableContextExtensions.AnnotationsInherited(Microsoft.CodeAnalysis.NullableContext) -M:Microsoft.CodeAnalysis.NullableContextExtensions.WarningsEnabled(Microsoft.CodeAnalysis.NullableContext) -M:Microsoft.CodeAnalysis.NullableContextExtensions.WarningsInherited(Microsoft.CodeAnalysis.NullableContext) -M:Microsoft.CodeAnalysis.NullableContextOptionsExtensions.AnnotationsEnabled(Microsoft.CodeAnalysis.NullableContextOptions) -M:Microsoft.CodeAnalysis.NullableContextOptionsExtensions.WarningsEnabled(Microsoft.CodeAnalysis.NullableContextOptions) -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_Exists -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsIdentity -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsImplicit -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsNullable -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsNumeric -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsReference -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_IsUserDefined -M:Microsoft.CodeAnalysis.Operations.CommonConversion.get_MethodSymbol -M:Microsoft.CodeAnalysis.Operations.IAddressOfOperation.get_Reference -M:Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation.get_Symbol -M:Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation.get_Initializers -M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_ArgumentKind -M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_InConversion -M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_OutConversion -M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_Parameter -M:Microsoft.CodeAnalysis.Operations.IArgumentOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IArrayCreationOperation.get_DimensionSizes -M:Microsoft.CodeAnalysis.Operations.IArrayCreationOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation.get_ArrayReference -M:Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation.get_Indices -M:Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation.get_ElementValues -M:Microsoft.CodeAnalysis.Operations.IAssignmentOperation.get_Target -M:Microsoft.CodeAnalysis.Operations.IAssignmentOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IAttributeOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IAwaitOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsChecked -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsCompareText -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_IsLifted -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_LeftOperand -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_OperatorKind -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_OperatorMethod -M:Microsoft.CodeAnalysis.Operations.IBinaryOperation.get_RightOperand -M:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_LeftPattern -M:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_OperatorKind -M:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation.get_RightPattern -M:Microsoft.CodeAnalysis.Operations.IBlockOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.IBlockOperation.get_Operations -M:Microsoft.CodeAnalysis.Operations.IBranchOperation.get_BranchKind -M:Microsoft.CodeAnalysis.Operations.IBranchOperation.get_Target -M:Microsoft.CodeAnalysis.Operations.ICaseClauseOperation.get_CaseKind -M:Microsoft.CodeAnalysis.Operations.ICaseClauseOperation.get_Label -M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_ExceptionDeclarationOrExpression -M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_ExceptionType -M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Filter -M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Handler -M:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_ValueConversion -M:Microsoft.CodeAnalysis.Operations.ICoalesceOperation.get_WhenNull -M:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_AddMethod -M:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation.get_IsDynamic -M:Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation.get_ConstructMethod -M:Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation.get_Elements -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_InConversion -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_IsChecked -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_IsLifted -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OperatorKind -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OperatorMethod -M:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation.get_OutConversion -M:Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation.get_WhenNotNull -M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_Condition -M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_IsRef -M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_WhenFalse -M:Microsoft.CodeAnalysis.Operations.IConditionalOperation.get_WhenTrue -M:Microsoft.CodeAnalysis.Operations.IConstantPatternOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_Conversion -M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_IsChecked -M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_IsTryCast -M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_Operand -M:Microsoft.CodeAnalysis.Operations.IConversionOperation.get_OperatorMethod -M:Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation.get_Expression -M:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_DeclaredSymbol -M:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_MatchedType -M:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation.get_MatchesNull -M:Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation.get_Target -M:Microsoft.CodeAnalysis.Operations.IDiscardOperation.get_DiscardSymbol -M:Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_ContainingType -M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_Instance -M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_MemberName -M:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation.get_TypeArguments -M:Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_Adds -M:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_EventReference -M:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.get_HandlerValue -M:Microsoft.CodeAnalysis.Operations.IEventReferenceOperation.get_Event -M:Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation.get_InitializedFields -M:Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation.get_Field -M:Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation.get_IsDeclaration -M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_Collection -M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_IsAsynchronous -M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_LoopControlVariable -M:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation.get_NextVariables -M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_AtLoopBottom -M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_Before -M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_Condition -M:Microsoft.CodeAnalysis.Operations.IForLoopOperation.get_ConditionLocals -M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_InitialValue -M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_IsChecked -M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_LimitValue -M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_LoopControlVariable -M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_NextVariables -M:Microsoft.CodeAnalysis.Operations.IForToLoopOperation.get_StepValue -M:Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation.get_Target -M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_Argument -M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_IndexerSymbol -M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_Instance -M:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation.get_LengthSymbol -M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsChecked -M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsLifted -M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_IsPostfix -M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_OperatorMethod -M:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation.get_Target -M:Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation.get_Argument -M:Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation.get_Instance -M:Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation.get_ReferenceKind -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation.get_Left -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation.get_Right -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation.get_AppendCall -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation.get_ArgumentIndex -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation.get_PlaceholderKind -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_Content -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerAppendCallsReturnBool -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerCreation -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation.get_HandlerCreationHasSuccessParameter -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation.get_Parts -M:Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation.get_Text -M:Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_Alignment -M:Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_Expression -M:Microsoft.CodeAnalysis.Operations.IInterpolationOperation.get_FormatString -M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_Instance -M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_IsVirtual -M:Microsoft.CodeAnalysis.Operations.IInvocationOperation.get_TargetMethod -M:Microsoft.CodeAnalysis.Operations.IIsPatternOperation.get_Pattern -M:Microsoft.CodeAnalysis.Operations.IIsPatternOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_IsNegated -M:Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_TypeOperand -M:Microsoft.CodeAnalysis.Operations.IIsTypeOperation.get_ValueOperand -M:Microsoft.CodeAnalysis.Operations.ILabeledOperation.get_Label -M:Microsoft.CodeAnalysis.Operations.ILabeledOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_DeclaredSymbol -M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_IndexerSymbol -M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_LengthSymbol -M:Microsoft.CodeAnalysis.Operations.IListPatternOperation.get_Patterns -M:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_IgnoredBody -M:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation.get_Symbol -M:Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation.get_IsDeclaration -M:Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation.get_Local -M:Microsoft.CodeAnalysis.Operations.ILockOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.ILockOperation.get_LockedValue -M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_ContinueLabel -M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_ExitLabel -M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.ILoopOperation.get_LoopKind -M:Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation.get_InitializedMember -M:Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_Instance -M:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation.get_Member -M:Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation.get_BlockBody -M:Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation.get_ExpressionBody -M:Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation.get_IsVirtual -M:Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation.get_Method -M:Microsoft.CodeAnalysis.Operations.INameOfOperation.get_Argument -M:Microsoft.CodeAnalysis.Operations.INegatedPatternOperation.get_Pattern -M:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Constructor -M:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation.get_Initializers -M:Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation.get_Parameter -M:Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation.get_Parameter -M:Microsoft.CodeAnalysis.Operations.IParenthesizedOperation.get_Operand -M:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Guard -M:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Label -M:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation.get_Pattern -M:Microsoft.CodeAnalysis.Operations.IPatternOperation.get_InputType -M:Microsoft.CodeAnalysis.Operations.IPatternOperation.get_NarrowedType -M:Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation.get_InitializedProperties -M:Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation.get_Property -M:Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation.get_Member -M:Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation.get_Pattern -M:Microsoft.CodeAnalysis.Operations.IRaiseEventOperation.get_Arguments -M:Microsoft.CodeAnalysis.Operations.IRaiseEventOperation.get_EventReference -M:Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation.get_MaximumValue -M:Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation.get_MinimumValue -M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_IsLifted -M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_LeftOperand -M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_Method -M:Microsoft.CodeAnalysis.Operations.IRangeOperation.get_RightOperand -M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeclaredSymbol -M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeconstructionSubpatterns -M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_DeconstructSymbol -M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_MatchedType -M:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation.get_PropertySubpatterns -M:Microsoft.CodeAnalysis.Operations.IReDimClauseOperation.get_DimensionSizes -M:Microsoft.CodeAnalysis.Operations.IReDimClauseOperation.get_Operand -M:Microsoft.CodeAnalysis.Operations.IReDimOperation.get_Clauses -M:Microsoft.CodeAnalysis.Operations.IReDimOperation.get_Preserve -M:Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation.get_Relation -M:Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation.get_OperatorKind -M:Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IReturnOperation.get_ReturnedValue -M:Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation.get_IsRef -M:Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.ISizeOfOperation.get_TypeOperand -M:Microsoft.CodeAnalysis.Operations.ISlicePatternOperation.get_Pattern -M:Microsoft.CodeAnalysis.Operations.ISlicePatternOperation.get_SliceSymbol -M:Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_ElementConversion -M:Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_ElementType -M:Microsoft.CodeAnalysis.Operations.ISpreadOperation.get_Operand -M:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Clauses -M:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Guard -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Pattern -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_Arms -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_IsExhaustive -M:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Cases -M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_ExitLabel -M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.ISwitchOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IThrowOperation.get_Exception -M:Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation.get_Operation -M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_Catches -M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_ExitLabel -M:Microsoft.CodeAnalysis.Operations.ITryOperation.get_Finally -M:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_LeftOperand -M:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_OperatorKind -M:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation.get_RightOperand -M:Microsoft.CodeAnalysis.Operations.ITupleOperation.get_Elements -M:Microsoft.CodeAnalysis.Operations.ITupleOperation.get_NaturalType -M:Microsoft.CodeAnalysis.Operations.ITypeOfOperation.get_TypeOperand -M:Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.ITypePatternOperation.get_MatchedType -M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_ConstrainedToType -M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_IsChecked -M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_IsLifted -M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_Operand -M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_OperatorKind -M:Microsoft.CodeAnalysis.Operations.IUnaryOperation.get_OperatorMethod -M:Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation.get_DeclarationGroup -M:Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation.get_IsAsynchronous -M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Body -M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_IsAsynchronous -M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Locals -M:Microsoft.CodeAnalysis.Operations.IUsingOperation.get_Resources -M:Microsoft.CodeAnalysis.Operations.IUtf8StringOperation.get_Value -M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation.get_Declarations -M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_Declarators -M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_IgnoredDimensions -M:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_IgnoredArguments -M:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation.get_Symbol -M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_Condition -M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_ConditionIsTop -M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_ConditionIsUntil -M:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation.get_IgnoredCondition -M:Microsoft.CodeAnalysis.Operations.IWithOperation.get_CloneMethod -M:Microsoft.CodeAnalysis.Operations.IWithOperation.get_Initializer -M:Microsoft.CodeAnalysis.Operations.IWithOperation.get_Operand -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.Descendants(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.DescendantsAndSelf(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,System.Int32) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,System.Int32) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentName(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,System.Int32) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,System.Int32) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,System.Int32) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetArgumentRefKind(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,System.Int32) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetCorrespondingOperation(Microsoft.CodeAnalysis.Operations.IBranchOperation) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetDeclaredVariables(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetDeclaredVariables(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetFunctionPointerSignature(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationExtensions.GetVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.#ctor -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.DefaultVisit(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.Visit(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAddressOf(Microsoft.CodeAnalysis.Operations.IAddressOfOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAnonymousFunction(Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAnonymousObjectCreation(Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArgument(Microsoft.CodeAnalysis.Operations.IArgumentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayCreation(Microsoft.CodeAnalysis.Operations.IArrayCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayElementReference(Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitArrayInitializer(Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAttribute(Microsoft.CodeAnalysis.Operations.IAttributeOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitAwait(Microsoft.CodeAnalysis.Operations.IAwaitOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBinaryOperator(Microsoft.CodeAnalysis.Operations.IBinaryOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBlock(Microsoft.CodeAnalysis.Operations.IBlockOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitBranch(Microsoft.CodeAnalysis.Operations.IBranchOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCatchClause(Microsoft.CodeAnalysis.Operations.ICatchClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCaughtException(Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCoalesce(Microsoft.CodeAnalysis.Operations.ICoalesceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCoalesceAssignment(Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCollectionElementInitializer(Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCollectionExpression(Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitCompoundAssignment(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditional(Microsoft.CodeAnalysis.Operations.IConditionalOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditionalAccess(Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConditionalAccessInstance(Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.Operations.IConstantPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConstructorBodyOperation(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDeconstructionAssignment(Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDefaultCaseClause(Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDefaultValue(Microsoft.CodeAnalysis.Operations.IDefaultValueOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDelegateCreation(Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDiscardOperation(Microsoft.CodeAnalysis.Operations.IDiscardOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicIndexerAccess(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicInvocation(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicMemberReference(Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitDynamicObjectCreation(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEmpty(Microsoft.CodeAnalysis.Operations.IEmptyOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEnd(Microsoft.CodeAnalysis.Operations.IEndOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEventAssignment(Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitEventReference(Microsoft.CodeAnalysis.Operations.IEventReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFieldInitializer(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFieldReference(Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowAnonymousFunction(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowCapture(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFlowCaptureReference(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForEachLoop(Microsoft.CodeAnalysis.Operations.IForEachLoopOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForLoop(Microsoft.CodeAnalysis.Operations.IForLoopOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitForToLoop(Microsoft.CodeAnalysis.Operations.IForToLoopOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitFunctionPointerInvocation(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitImplicitIndexerReference(Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIncrementOrDecrement(Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInlineArrayAccess(Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInstanceReference(Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedString(Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringAddition(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringAppend(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringHandlerArgumentPlaceholder(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringHandlerCreation(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInterpolation(Microsoft.CodeAnalysis.Operations.IInterpolationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInvalid(Microsoft.CodeAnalysis.Operations.IInvalidOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitInvocation(Microsoft.CodeAnalysis.Operations.IInvocationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsNull(Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsPattern(Microsoft.CodeAnalysis.Operations.IIsPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitIsType(Microsoft.CodeAnalysis.Operations.IIsTypeOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLabeled(Microsoft.CodeAnalysis.Operations.ILabeledOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitListPattern(Microsoft.CodeAnalysis.Operations.IListPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLiteral(Microsoft.CodeAnalysis.Operations.ILiteralOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLocalFunction(Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLocalReference(Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitLock(Microsoft.CodeAnalysis.Operations.ILockOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMemberInitializer(Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMethodBodyOperation(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitMethodReference(Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitNameOf(Microsoft.CodeAnalysis.Operations.INameOfOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitNegatedPattern(Microsoft.CodeAnalysis.Operations.INegatedPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitObjectCreation(Microsoft.CodeAnalysis.Operations.IObjectCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitObjectOrCollectionInitializer(Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitOmittedArgument(Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParameterInitializer(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParameterReference(Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitParenthesized(Microsoft.CodeAnalysis.Operations.IParenthesizedOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPatternCaseClause(Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertyInitializer(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertyReference(Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitPropertySubpattern(Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRaiseEvent(Microsoft.CodeAnalysis.Operations.IRaiseEventOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRangeCaseClause(Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRangeOperation(Microsoft.CodeAnalysis.Operations.IRangeOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReDim(Microsoft.CodeAnalysis.Operations.IReDimOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReDimClause(Microsoft.CodeAnalysis.Operations.IReDimClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRelationalCaseClause(Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitReturn(Microsoft.CodeAnalysis.Operations.IReturnOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSimpleAssignment(Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSingleValueCaseClause(Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSizeOf(Microsoft.CodeAnalysis.Operations.ISizeOfOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.Operations.ISlicePatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSpread(Microsoft.CodeAnalysis.Operations.ISpreadOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitStaticLocalInitializationSemaphore(Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitStop(Microsoft.CodeAnalysis.Operations.IStopOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitch(Microsoft.CodeAnalysis.Operations.ISwitchOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchCase(Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitThrow(Microsoft.CodeAnalysis.Operations.IThrowOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTranslatedQuery(Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTry(Microsoft.CodeAnalysis.Operations.ITryOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTuple(Microsoft.CodeAnalysis.Operations.ITupleOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTupleBinaryOperator(Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypeOf(Microsoft.CodeAnalysis.Operations.ITypeOfOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypeParameterObjectCreation(Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitTypePattern(Microsoft.CodeAnalysis.Operations.ITypePatternOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUnaryOperator(Microsoft.CodeAnalysis.Operations.IUnaryOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUsing(Microsoft.CodeAnalysis.Operations.IUsingOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUsingDeclaration(Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitUtf8String(Microsoft.CodeAnalysis.Operations.IUtf8StringOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclarationGroup(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitWhileLoop(Microsoft.CodeAnalysis.Operations.IWhileLoopOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor.VisitWith(Microsoft.CodeAnalysis.Operations.IWithOperation) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.#ctor -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.DefaultVisit(Microsoft.CodeAnalysis.IOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.Visit(Microsoft.CodeAnalysis.IOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAddressOf(Microsoft.CodeAnalysis.Operations.IAddressOfOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAnonymousFunction(Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAnonymousObjectCreation(Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArgument(Microsoft.CodeAnalysis.Operations.IArgumentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayCreation(Microsoft.CodeAnalysis.Operations.IArrayCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayElementReference(Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitArrayInitializer(Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAttribute(Microsoft.CodeAnalysis.Operations.IAttributeOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitAwait(Microsoft.CodeAnalysis.Operations.IAwaitOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBinaryOperator(Microsoft.CodeAnalysis.Operations.IBinaryOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBinaryPattern(Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBlock(Microsoft.CodeAnalysis.Operations.IBlockOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitBranch(Microsoft.CodeAnalysis.Operations.IBranchOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCatchClause(Microsoft.CodeAnalysis.Operations.ICatchClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCaughtException(Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCoalesce(Microsoft.CodeAnalysis.Operations.ICoalesceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCoalesceAssignment(Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCollectionElementInitializer(Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCollectionExpression(Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitCompoundAssignment(Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditional(Microsoft.CodeAnalysis.Operations.IConditionalOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditionalAccess(Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConditionalAccessInstance(Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConstantPattern(Microsoft.CodeAnalysis.Operations.IConstantPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConstructorBodyOperation(Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitConversion(Microsoft.CodeAnalysis.Operations.IConversionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeclarationExpression(Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeclarationPattern(Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDeconstructionAssignment(Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDefaultCaseClause(Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDefaultValue(Microsoft.CodeAnalysis.Operations.IDefaultValueOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDelegateCreation(Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDiscardOperation(Microsoft.CodeAnalysis.Operations.IDiscardOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDiscardPattern(Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicIndexerAccess(Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicInvocation(Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicMemberReference(Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitDynamicObjectCreation(Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEmpty(Microsoft.CodeAnalysis.Operations.IEmptyOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEnd(Microsoft.CodeAnalysis.Operations.IEndOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEventAssignment(Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitEventReference(Microsoft.CodeAnalysis.Operations.IEventReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitExpressionStatement(Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFieldInitializer(Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFieldReference(Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowAnonymousFunction(Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowCapture(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFlowCaptureReference(Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForEachLoop(Microsoft.CodeAnalysis.Operations.IForEachLoopOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForLoop(Microsoft.CodeAnalysis.Operations.IForLoopOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitForToLoop(Microsoft.CodeAnalysis.Operations.IForToLoopOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitFunctionPointerInvocation(Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitImplicitIndexerReference(Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIncrementOrDecrement(Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInlineArrayAccess(Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInstanceReference(Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedString(Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringAddition(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringAppend(Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringHandlerArgumentPlaceholder(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringHandlerCreation(Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolatedStringText(Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInterpolation(Microsoft.CodeAnalysis.Operations.IInterpolationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInvalid(Microsoft.CodeAnalysis.Operations.IInvalidOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitInvocation(Microsoft.CodeAnalysis.Operations.IInvocationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsNull(Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsPattern(Microsoft.CodeAnalysis.Operations.IIsPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitIsType(Microsoft.CodeAnalysis.Operations.IIsTypeOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLabeled(Microsoft.CodeAnalysis.Operations.ILabeledOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitListPattern(Microsoft.CodeAnalysis.Operations.IListPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLiteral(Microsoft.CodeAnalysis.Operations.ILiteralOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLocalFunction(Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLocalReference(Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitLock(Microsoft.CodeAnalysis.Operations.ILockOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMemberInitializer(Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMethodBodyOperation(Microsoft.CodeAnalysis.Operations.IMethodBodyOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitMethodReference(Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitNameOf(Microsoft.CodeAnalysis.Operations.INameOfOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitNegatedPattern(Microsoft.CodeAnalysis.Operations.INegatedPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitObjectCreation(Microsoft.CodeAnalysis.Operations.IObjectCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitObjectOrCollectionInitializer(Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitOmittedArgument(Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParameterInitializer(Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParameterReference(Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitParenthesized(Microsoft.CodeAnalysis.Operations.IParenthesizedOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPatternCaseClause(Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertyInitializer(Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertyReference(Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitPropertySubpattern(Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRaiseEvent(Microsoft.CodeAnalysis.Operations.IRaiseEventOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRangeCaseClause(Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRangeOperation(Microsoft.CodeAnalysis.Operations.IRangeOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRecursivePattern(Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReDim(Microsoft.CodeAnalysis.Operations.IReDimOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReDimClause(Microsoft.CodeAnalysis.Operations.IReDimClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRelationalCaseClause(Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitRelationalPattern(Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitReturn(Microsoft.CodeAnalysis.Operations.IReturnOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSimpleAssignment(Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSingleValueCaseClause(Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSizeOf(Microsoft.CodeAnalysis.Operations.ISizeOfOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSlicePattern(Microsoft.CodeAnalysis.Operations.ISlicePatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSpread(Microsoft.CodeAnalysis.Operations.ISpreadOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitStaticLocalInitializationSemaphore(Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitStop(Microsoft.CodeAnalysis.Operations.IStopOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitch(Microsoft.CodeAnalysis.Operations.ISwitchOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchCase(Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchExpression(Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitThrow(Microsoft.CodeAnalysis.Operations.IThrowOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTranslatedQuery(Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTry(Microsoft.CodeAnalysis.Operations.ITryOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTuple(Microsoft.CodeAnalysis.Operations.ITupleOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTupleBinaryOperator(Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypeOf(Microsoft.CodeAnalysis.Operations.ITypeOfOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypeParameterObjectCreation(Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitTypePattern(Microsoft.CodeAnalysis.Operations.ITypePatternOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUnaryOperator(Microsoft.CodeAnalysis.Operations.IUnaryOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUsing(Microsoft.CodeAnalysis.Operations.IUsingOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUsingDeclaration(Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitUtf8String(Microsoft.CodeAnalysis.Operations.IUtf8StringOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclaration(Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclarationGroup(Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableDeclarator(Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitVariableInitializer(Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitWhileLoop(Microsoft.CodeAnalysis.Operations.IWhileLoopOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationVisitor`2.VisitWith(Microsoft.CodeAnalysis.Operations.IWithOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationWalker.#ctor -M:Microsoft.CodeAnalysis.Operations.OperationWalker.DefaultVisit(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Operations.OperationWalker.Visit(Microsoft.CodeAnalysis.IOperation) -M:Microsoft.CodeAnalysis.Operations.OperationWalker`1.#ctor -M:Microsoft.CodeAnalysis.Operations.OperationWalker`1.DefaultVisit(Microsoft.CodeAnalysis.IOperation,`0) -M:Microsoft.CodeAnalysis.Operations.OperationWalker`1.Visit(Microsoft.CodeAnalysis.IOperation,`0) -M:Microsoft.CodeAnalysis.Optional`1.#ctor(`0) -M:Microsoft.CodeAnalysis.Optional`1.get_HasValue -M:Microsoft.CodeAnalysis.Optional`1.get_Value -M:Microsoft.CodeAnalysis.Optional`1.op_Implicit(`0)~Microsoft.CodeAnalysis.Optional{`0} -M:Microsoft.CodeAnalysis.Optional`1.ToString -M:Microsoft.CodeAnalysis.ParseOptions.CommonWithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) -M:Microsoft.CodeAnalysis.ParseOptions.CommonWithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) -M:Microsoft.CodeAnalysis.ParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind) -M:Microsoft.CodeAnalysis.ParseOptions.Equals(System.Object) -M:Microsoft.CodeAnalysis.ParseOptions.EqualsHelper(Microsoft.CodeAnalysis.ParseOptions) -M:Microsoft.CodeAnalysis.ParseOptions.get_DocumentationMode -M:Microsoft.CodeAnalysis.ParseOptions.get_Errors -M:Microsoft.CodeAnalysis.ParseOptions.get_Features -M:Microsoft.CodeAnalysis.ParseOptions.get_Kind -M:Microsoft.CodeAnalysis.ParseOptions.get_Language -M:Microsoft.CodeAnalysis.ParseOptions.get_PreprocessorSymbolNames -M:Microsoft.CodeAnalysis.ParseOptions.get_SpecifiedKind -M:Microsoft.CodeAnalysis.ParseOptions.GetHashCode -M:Microsoft.CodeAnalysis.ParseOptions.GetHashCodeHelper -M:Microsoft.CodeAnalysis.ParseOptions.op_Equality(Microsoft.CodeAnalysis.ParseOptions,Microsoft.CodeAnalysis.ParseOptions) -M:Microsoft.CodeAnalysis.ParseOptions.op_Inequality(Microsoft.CodeAnalysis.ParseOptions,Microsoft.CodeAnalysis.ParseOptions) -M:Microsoft.CodeAnalysis.ParseOptions.set_DocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) -M:Microsoft.CodeAnalysis.ParseOptions.set_Kind(Microsoft.CodeAnalysis.SourceCodeKind) -M:Microsoft.CodeAnalysis.ParseOptions.set_SpecifiedKind(Microsoft.CodeAnalysis.SourceCodeKind) -M:Microsoft.CodeAnalysis.ParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode) -M:Microsoft.CodeAnalysis.ParseOptions.WithFeatures(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}}) -M:Microsoft.CodeAnalysis.ParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind) -M:Microsoft.CodeAnalysis.PortableExecutableReference.#ctor(Microsoft.CodeAnalysis.MetadataReferenceProperties,System.String,Microsoft.CodeAnalysis.DocumentationProvider) -M:Microsoft.CodeAnalysis.PortableExecutableReference.CreateDocumentationProvider -M:Microsoft.CodeAnalysis.PortableExecutableReference.get_Display -M:Microsoft.CodeAnalysis.PortableExecutableReference.get_FilePath -M:Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadata -M:Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataId -M:Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataImpl -M:Microsoft.CodeAnalysis.PortableExecutableReference.WithAliases(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.PortableExecutableReference.WithAliases(System.Collections.Immutable.ImmutableArray{System.String}) -M:Microsoft.CodeAnalysis.PortableExecutableReference.WithEmbedInteropTypes(System.Boolean) -M:Microsoft.CodeAnalysis.PortableExecutableReference.WithProperties(Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.PortableExecutableReference.WithPropertiesImpl(Microsoft.CodeAnalysis.MetadataReferenceProperties) -M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.Equals(Microsoft.CodeAnalysis.PreprocessingSymbolInfo) -M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.get_IsDefined -M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.get_Symbol -M:Microsoft.CodeAnalysis.PreprocessingSymbolInfo.GetHashCode -M:Microsoft.CodeAnalysis.ResourceDescription.#ctor(System.String,System.Func{System.IO.Stream},System.Boolean) -M:Microsoft.CodeAnalysis.ResourceDescription.#ctor(System.String,System.String,System.Func{System.IO.Stream},System.Boolean) -M:Microsoft.CodeAnalysis.RuleSet.#ctor(System.String,Microsoft.CodeAnalysis.ReportDiagnostic,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.RuleSetInclude}) -M:Microsoft.CodeAnalysis.RuleSet.get_FilePath -M:Microsoft.CodeAnalysis.RuleSet.get_GeneralDiagnosticOption -M:Microsoft.CodeAnalysis.RuleSet.get_Includes -M:Microsoft.CodeAnalysis.RuleSet.get_SpecificDiagnosticOptions -M:Microsoft.CodeAnalysis.RuleSet.GetDiagnosticOptionsFromRulesetFile(System.String,System.Collections.Generic.Dictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}@) -M:Microsoft.CodeAnalysis.RuleSet.GetEffectiveIncludesFromFile(System.String) -M:Microsoft.CodeAnalysis.RuleSet.LoadEffectiveRuleSetFromFile(System.String) -M:Microsoft.CodeAnalysis.RuleSet.WithEffectiveAction(Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.RuleSetInclude.#ctor(System.String,Microsoft.CodeAnalysis.ReportDiagnostic) -M:Microsoft.CodeAnalysis.RuleSetInclude.get_Action -M:Microsoft.CodeAnalysis.RuleSetInclude.get_IncludePath -M:Microsoft.CodeAnalysis.RuleSetInclude.LoadRuleSet(Microsoft.CodeAnalysis.RuleSet) -M:Microsoft.CodeAnalysis.SarifVersionFacts.TryParse(System.String,Microsoft.CodeAnalysis.SarifVersion@) -M:Microsoft.CodeAnalysis.ScriptCompilationInfo.get_GlobalsType -M:Microsoft.CodeAnalysis.ScriptCompilationInfo.get_PreviousScriptCompilation -M:Microsoft.CodeAnalysis.ScriptCompilationInfo.get_ReturnType -M:Microsoft.CodeAnalysis.ScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.Compilation) -M:Microsoft.CodeAnalysis.SemanticModel.#ctor -M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeControlFlowCore(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeControlFlowCore(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeDataFlowCore(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.AnalyzeDataFlowCore(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.get_Compilation -M:Microsoft.CodeAnalysis.SemanticModel.get_CompilationCore -M:Microsoft.CodeAnalysis.SemanticModel.get_IgnoresAccessibility -M:Microsoft.CodeAnalysis.SemanticModel.get_IsSpeculativeSemanticModel -M:Microsoft.CodeAnalysis.SemanticModel.get_Language -M:Microsoft.CodeAnalysis.SemanticModel.get_NullableAnalysisIsDisabled -M:Microsoft.CodeAnalysis.SemanticModel.get_OriginalPositionForSpeculation -M:Microsoft.CodeAnalysis.SemanticModel.get_ParentModel -M:Microsoft.CodeAnalysis.SemanticModel.get_ParentModelCore -M:Microsoft.CodeAnalysis.SemanticModel.get_RootCore -M:Microsoft.CodeAnalysis.SemanticModel.get_SyntaxTree -M:Microsoft.CodeAnalysis.SemanticModel.get_SyntaxTreeCore -M:Microsoft.CodeAnalysis.SemanticModel.GetAliasInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetConstantValue(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetConstantValueCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetDeclarationDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetDeclaredSymbolCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetDeclaredSymbolsCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetEnclosingSymbol(System.Int32,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetEnclosingSymbolCore(System.Int32,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetImportScopes(System.Int32,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetMemberGroupCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetMethodBodyDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetNullableContext(System.Int32) -M:Microsoft.CodeAnalysis.SemanticModel.GetOperation(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetOperationCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetPreprocessingSymbolInfo(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.GetPreprocessingSymbolInfoCore(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeAliasInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeSymbolInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.SemanticModel.GetSpeculativeTypeInfoCore(System.Int32,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SpeculativeBindingOption) -M:Microsoft.CodeAnalysis.SemanticModel.GetSymbolInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetSyntaxDiagnostics(System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.GetTopmostNodeForDiagnosticAnalysis(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SemanticModel.GetTypeInfoCore(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SemanticModel.IsAccessible(System.Int32,Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SemanticModel.IsAccessibleCore(System.Int32,Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SemanticModel.IsEventUsableAsField(System.Int32,Microsoft.CodeAnalysis.IEventSymbol) -M:Microsoft.CodeAnalysis.SemanticModel.IsEventUsableAsFieldCore(System.Int32,Microsoft.CodeAnalysis.IEventSymbol) -M:Microsoft.CodeAnalysis.SemanticModel.LookupBaseMembers(System.Int32,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupBaseMembersCore(System.Int32,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupLabels(System.Int32,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupLabelsCore(System.Int32,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupNamespacesAndTypes(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupNamespacesAndTypesCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupStaticMembers(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupStaticMembersCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String) -M:Microsoft.CodeAnalysis.SemanticModel.LookupSymbols(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.SemanticModel.LookupSymbolsCore(System.Int32,Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList.Create``1(System.ReadOnlySpan{``0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Add(`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Any -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Contains(`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.Equals(System.Object) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.GetHashCode -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator.Reset -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Equals(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Equals(System.Object) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.First -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.FirstOrDefault -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Count -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_FullSpan -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_SeparatorCount -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.get_Span -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetEnumerator -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetHashCode -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetSeparator(System.Int32) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetSeparators -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.GetWithSeparators -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.IndexOf(`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.IndexOf(System.Func{`0,System.Boolean}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Insert(System.Int32,`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Last -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastIndexOf(`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastIndexOf(System.Func{`0,System.Boolean}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.LastOrDefault -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Equality(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0},Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Explicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode})~Microsoft.CodeAnalysis.SeparatedSyntaxList{`0} -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0})~Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode} -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.op_Inequality(Microsoft.CodeAnalysis.SeparatedSyntaxList{`0},Microsoft.CodeAnalysis.SeparatedSyntaxList{`0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Remove(`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.RemoveAt(System.Int32) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Replace(`0,`0) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ReplaceRange(`0,System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ReplaceSeparator(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ToFullString -M:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.ToString -M:Microsoft.CodeAnalysis.SourceFileResolver.#ctor(System.Collections.Generic.IEnumerable{System.String},System.String) -M:Microsoft.CodeAnalysis.SourceFileResolver.#ctor(System.Collections.Immutable.ImmutableArray{System.String},System.String) -M:Microsoft.CodeAnalysis.SourceFileResolver.#ctor(System.Collections.Immutable.ImmutableArray{System.String},System.String,System.Collections.Immutable.ImmutableArray{System.Collections.Generic.KeyValuePair{System.String,System.String}}) -M:Microsoft.CodeAnalysis.SourceFileResolver.Equals(Microsoft.CodeAnalysis.SourceFileResolver) -M:Microsoft.CodeAnalysis.SourceFileResolver.Equals(System.Object) -M:Microsoft.CodeAnalysis.SourceFileResolver.FileExists(System.String) -M:Microsoft.CodeAnalysis.SourceFileResolver.get_BaseDirectory -M:Microsoft.CodeAnalysis.SourceFileResolver.get_Default -M:Microsoft.CodeAnalysis.SourceFileResolver.get_PathMap -M:Microsoft.CodeAnalysis.SourceFileResolver.get_SearchPaths -M:Microsoft.CodeAnalysis.SourceFileResolver.GetHashCode -M:Microsoft.CodeAnalysis.SourceFileResolver.NormalizePath(System.String,System.String) -M:Microsoft.CodeAnalysis.SourceFileResolver.OpenRead(System.String) -M:Microsoft.CodeAnalysis.SourceFileResolver.ResolveReference(System.String,System.String) -M:Microsoft.CodeAnalysis.SourceProductionContext.AddSource(System.String,Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.SourceProductionContext.AddSource(System.String,System.String) -M:Microsoft.CodeAnalysis.SourceProductionContext.get_CancellationToken -M:Microsoft.CodeAnalysis.SourceProductionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic) -M:Microsoft.CodeAnalysis.SourceReferenceResolver.#ctor -M:Microsoft.CodeAnalysis.SourceReferenceResolver.Equals(System.Object) -M:Microsoft.CodeAnalysis.SourceReferenceResolver.GetHashCode -M:Microsoft.CodeAnalysis.SourceReferenceResolver.NormalizePath(System.String,System.String) -M:Microsoft.CodeAnalysis.SourceReferenceResolver.OpenRead(System.String) -M:Microsoft.CodeAnalysis.SourceReferenceResolver.ReadText(System.String) -M:Microsoft.CodeAnalysis.SourceReferenceResolver.ResolveReference(System.String,System.String) -M:Microsoft.CodeAnalysis.StrongNameProvider.#ctor -M:Microsoft.CodeAnalysis.StrongNameProvider.Equals(System.Object) -M:Microsoft.CodeAnalysis.StrongNameProvider.GetHashCode -M:Microsoft.CodeAnalysis.SubsystemVersion.Create(System.Int32,System.Int32) -M:Microsoft.CodeAnalysis.SubsystemVersion.Equals(Microsoft.CodeAnalysis.SubsystemVersion) -M:Microsoft.CodeAnalysis.SubsystemVersion.Equals(System.Object) -M:Microsoft.CodeAnalysis.SubsystemVersion.get_IsValid -M:Microsoft.CodeAnalysis.SubsystemVersion.get_Major -M:Microsoft.CodeAnalysis.SubsystemVersion.get_Minor -M:Microsoft.CodeAnalysis.SubsystemVersion.get_None -M:Microsoft.CodeAnalysis.SubsystemVersion.get_Windows2000 -M:Microsoft.CodeAnalysis.SubsystemVersion.get_Windows7 -M:Microsoft.CodeAnalysis.SubsystemVersion.get_Windows8 -M:Microsoft.CodeAnalysis.SubsystemVersion.get_WindowsVista -M:Microsoft.CodeAnalysis.SubsystemVersion.get_WindowsXP -M:Microsoft.CodeAnalysis.SubsystemVersion.GetHashCode -M:Microsoft.CodeAnalysis.SubsystemVersion.ToString -M:Microsoft.CodeAnalysis.SubsystemVersion.TryParse(System.String,Microsoft.CodeAnalysis.SubsystemVersion@) -M:Microsoft.CodeAnalysis.SuppressionDescriptor.#ctor(System.String,System.String,Microsoft.CodeAnalysis.LocalizableString) -M:Microsoft.CodeAnalysis.SuppressionDescriptor.#ctor(System.String,System.String,System.String) -M:Microsoft.CodeAnalysis.SuppressionDescriptor.Equals(Microsoft.CodeAnalysis.SuppressionDescriptor) -M:Microsoft.CodeAnalysis.SuppressionDescriptor.Equals(System.Object) -M:Microsoft.CodeAnalysis.SuppressionDescriptor.get_Id -M:Microsoft.CodeAnalysis.SuppressionDescriptor.get_Justification -M:Microsoft.CodeAnalysis.SuppressionDescriptor.get_SuppressedDiagnosticId -M:Microsoft.CodeAnalysis.SuppressionDescriptor.GetHashCode -M:Microsoft.CodeAnalysis.SymbolDisplayExtensions.ToDisplayString(System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.SymbolDisplayPart}) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.#ctor(Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle,Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle,Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions,Microsoft.CodeAnalysis.SymbolDisplayMemberOptions,Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle,Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle,Microsoft.CodeAnalysis.SymbolDisplayParameterOptions,Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle,Microsoft.CodeAnalysis.SymbolDisplayLocalOptions,Microsoft.CodeAnalysis.SymbolDisplayKindOptions,Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.AddParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_CSharpErrorMessageFormat -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_CSharpShortErrorMessageFormat -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_DelegateStyle -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_ExtensionMethodStyle -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_FullyQualifiedFormat -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_GenericsOptions -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_GlobalNamespaceStyle -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_KindOptions -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_LocalOptions -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MemberOptions -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MinimallyQualifiedFormat -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_MiscellaneousOptions -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_ParameterOptions -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_PropertyStyle -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_TypeQualificationStyle -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_VisualBasicErrorMessageFormat -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.get_VisualBasicShortErrorMessageFormat -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithGlobalNamespaceStyle(Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithKindOptions(Microsoft.CodeAnalysis.SymbolDisplayKindOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithLocalOptions(Microsoft.CodeAnalysis.SymbolDisplayLocalOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithMemberOptions(Microsoft.CodeAnalysis.SymbolDisplayMemberOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithMiscellaneousOptions(Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayFormat.WithParameterOptions(Microsoft.CodeAnalysis.SymbolDisplayParameterOptions) -M:Microsoft.CodeAnalysis.SymbolDisplayPart.#ctor(Microsoft.CodeAnalysis.SymbolDisplayPartKind,Microsoft.CodeAnalysis.ISymbol,System.String) -M:Microsoft.CodeAnalysis.SymbolDisplayPart.get_Kind -M:Microsoft.CodeAnalysis.SymbolDisplayPart.get_Symbol -M:Microsoft.CodeAnalysis.SymbolDisplayPart.ToString -M:Microsoft.CodeAnalysis.SymbolEqualityComparer.Equals(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SymbolEqualityComparer.GetHashCode(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SymbolInfo.Equals(Microsoft.CodeAnalysis.SymbolInfo) -M:Microsoft.CodeAnalysis.SymbolInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.SymbolInfo.get_CandidateReason -M:Microsoft.CodeAnalysis.SymbolInfo.get_CandidateSymbols -M:Microsoft.CodeAnalysis.SymbolInfo.get_Symbol -M:Microsoft.CodeAnalysis.SymbolInfo.GetHashCode -M:Microsoft.CodeAnalysis.SymbolVisitor.#ctor -M:Microsoft.CodeAnalysis.SymbolVisitor.DefaultVisit(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.Visit(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitField(Microsoft.CodeAnalysis.IFieldSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.#ctor -M:Microsoft.CodeAnalysis.SymbolVisitor`1.DefaultVisit(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.Visit(Microsoft.CodeAnalysis.ISymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitField(Microsoft.CodeAnalysis.IFieldSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`1.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.#ctor -M:Microsoft.CodeAnalysis.SymbolVisitor`2.DefaultVisit(Microsoft.CodeAnalysis.ISymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.get_DefaultResult -M:Microsoft.CodeAnalysis.SymbolVisitor`2.Visit(Microsoft.CodeAnalysis.ISymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitAlias(Microsoft.CodeAnalysis.IAliasSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitArrayType(Microsoft.CodeAnalysis.IArrayTypeSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitAssembly(Microsoft.CodeAnalysis.IAssemblySymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitDiscard(Microsoft.CodeAnalysis.IDiscardSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitDynamicType(Microsoft.CodeAnalysis.IDynamicTypeSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitEvent(Microsoft.CodeAnalysis.IEventSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitField(Microsoft.CodeAnalysis.IFieldSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitFunctionPointerType(Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitLabel(Microsoft.CodeAnalysis.ILabelSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitLocal(Microsoft.CodeAnalysis.ILocalSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitMethod(Microsoft.CodeAnalysis.IMethodSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitModule(Microsoft.CodeAnalysis.IModuleSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitNamedType(Microsoft.CodeAnalysis.INamedTypeSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitNamespace(Microsoft.CodeAnalysis.INamespaceSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitParameter(Microsoft.CodeAnalysis.IParameterSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitPointerType(Microsoft.CodeAnalysis.IPointerTypeSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol,`0) -M:Microsoft.CodeAnalysis.SymbolVisitor`2.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol,`0) -M:Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor -M:Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor(System.String) -M:Microsoft.CodeAnalysis.SyntaxAnnotation.#ctor(System.String,System.String) -M:Microsoft.CodeAnalysis.SyntaxAnnotation.Equals(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxAnnotation.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxAnnotation.get_Data -M:Microsoft.CodeAnalysis.SyntaxAnnotation.get_ElasticAnnotation -M:Microsoft.CodeAnalysis.SyntaxAnnotation.get_Kind -M:Microsoft.CodeAnalysis.SyntaxAnnotation.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxAnnotation.op_Equality(Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxAnnotation.op_Inequality(Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.#ctor(System.Object,System.IntPtr) -M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.BeginInvoke(System.AsyncCallback,System.Object) -M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.EndInvoke(System.IAsyncResult) -M:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator.Invoke -M:Microsoft.CodeAnalysis.SyntaxList.Create``1(System.ReadOnlySpan{``0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.#ctor(`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.Add(`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.Any -M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator.Reset -M:Microsoft.CodeAnalysis.SyntaxList`1.Equals(Microsoft.CodeAnalysis.SyntaxList{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxList`1.First -M:Microsoft.CodeAnalysis.SyntaxList`1.FirstOrDefault -M:Microsoft.CodeAnalysis.SyntaxList`1.get_Count -M:Microsoft.CodeAnalysis.SyntaxList`1.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxList`1.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxList`1.get_Span -M:Microsoft.CodeAnalysis.SyntaxList`1.GetEnumerator -M:Microsoft.CodeAnalysis.SyntaxList`1.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxList`1.IndexOf(`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.IndexOf(System.Func{`0,System.Boolean}) -M:Microsoft.CodeAnalysis.SyntaxList`1.Insert(System.Int32,`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.Last -M:Microsoft.CodeAnalysis.SyntaxList`1.LastIndexOf(`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.LastIndexOf(System.Func{`0,System.Boolean}) -M:Microsoft.CodeAnalysis.SyntaxList`1.LastOrDefault -M:Microsoft.CodeAnalysis.SyntaxList`1.op_Equality(Microsoft.CodeAnalysis.SyntaxList{`0},Microsoft.CodeAnalysis.SyntaxList{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.op_Explicit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode})~Microsoft.CodeAnalysis.SyntaxList{`0} -M:Microsoft.CodeAnalysis.SyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SyntaxList{`0})~Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode} -M:Microsoft.CodeAnalysis.SyntaxList`1.op_Implicit(Microsoft.CodeAnalysis.SyntaxList{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxList`1.op_Inequality(Microsoft.CodeAnalysis.SyntaxList{`0},Microsoft.CodeAnalysis.SyntaxList{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.Remove(`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.RemoveAt(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxList`1.Replace(`0,`0) -M:Microsoft.CodeAnalysis.SyntaxList`1.ReplaceRange(`0,System.Collections.Generic.IEnumerable{`0}) -M:Microsoft.CodeAnalysis.SyntaxList`1.ToFullString -M:Microsoft.CodeAnalysis.SyntaxList`1.ToString -M:Microsoft.CodeAnalysis.SyntaxNode.Ancestors(System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.AncestorsAndSelf(System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.ChildNodes -M:Microsoft.CodeAnalysis.SyntaxNode.ChildNodesAndTokens -M:Microsoft.CodeAnalysis.SyntaxNode.ChildThatContainsPosition(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxNode.ChildTokens -M:Microsoft.CodeAnalysis.SyntaxNode.Contains(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxNode.ContainsDirective(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxNode.CopyAnnotationsTo``1(``0) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodes(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodes(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndSelf(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndSelf(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokens(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokens(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokensAndSelf(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantNodesAndTokensAndSelf(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTokens(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTokens(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTrivia(Microsoft.CodeAnalysis.Text.TextSpan,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.DescendantTrivia(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.EquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxNode.FindNode(Microsoft.CodeAnalysis.Text.TextSpan,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.FindToken(System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.FindTokenCore(System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.FindTokenCore(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) -M:Microsoft.CodeAnalysis.SyntaxNode.FindTrivia(System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.FindTrivia(System.Int32,System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,System.Boolean}) -M:Microsoft.CodeAnalysis.SyntaxNode.FindTriviaCore(System.Int32,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf``1(System.Func{``0,System.Boolean},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf``2(System.Func{``0,``1,System.Boolean},``1,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsAnnotations -M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsDiagnostics -M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsDirectives -M:Microsoft.CodeAnalysis.SyntaxNode.get_ContainsSkippedText -M:Microsoft.CodeAnalysis.SyntaxNode.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxNode.get_HasLeadingTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.get_HasStructuredTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.get_HasTrailingTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.get_IsMissing -M:Microsoft.CodeAnalysis.SyntaxNode.get_IsStructuredTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.get_KindText -M:Microsoft.CodeAnalysis.SyntaxNode.get_Language -M:Microsoft.CodeAnalysis.SyntaxNode.get_Parent -M:Microsoft.CodeAnalysis.SyntaxNode.get_ParentTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.get_RawKind -M:Microsoft.CodeAnalysis.SyntaxNode.get_Span -M:Microsoft.CodeAnalysis.SyntaxNode.get_SpanStart -M:Microsoft.CodeAnalysis.SyntaxNode.get_SyntaxTree -M:Microsoft.CodeAnalysis.SyntaxNode.get_SyntaxTreeCore -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodes(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodes(System.String) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(System.String) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedNodesAndTokens(System.String[]) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTokens(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTokens(System.String) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(System.String) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotatedTrivia(System.String[]) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.SyntaxNode.GetAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxNode.GetDiagnostics -M:Microsoft.CodeAnalysis.SyntaxNode.GetFirstToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.GetLastToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.GetLeadingTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.GetLocation -M:Microsoft.CodeAnalysis.SyntaxNode.GetRed``1(``0@,System.Int32) -M:Microsoft.CodeAnalysis.SyntaxNode.GetRedAtZero``1(``0@) -M:Microsoft.CodeAnalysis.SyntaxNode.GetReference -M:Microsoft.CodeAnalysis.SyntaxNode.GetText(System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) -M:Microsoft.CodeAnalysis.SyntaxNode.GetTrailingTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxNode.HasAnnotations(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.SyntaxNode.HasAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxNode.InsertNodesInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.InsertTokensInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.InsertTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentToCore(Microsoft.CodeAnalysis.SyntaxNode,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxNode.IsPartOfStructuredTrivia -M:Microsoft.CodeAnalysis.SyntaxNode.NormalizeWhitespaceCore(System.String,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNode.RemoveNodesCore(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) -M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceCore``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceNodeInListCore(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceTokenInListCore(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxNode.ReplaceTriviaInListCore(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNode.SerializeTo(System.IO.Stream,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxNode.ToFullString -M:Microsoft.CodeAnalysis.SyntaxNode.ToString -M:Microsoft.CodeAnalysis.SyntaxNode.WriteTo(System.IO.TextWriter) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNode``1(Microsoft.CodeAnalysis.SyntaxNode,``0) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNodes``1(Microsoft.CodeAnalysis.SyntaxNode,``0) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.GetCurrentNodes``1(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{``0}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertNodesAfter``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertNodesBefore``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTokensAfter``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTokensBefore``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTriviaAfter``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.InsertTriviaBefore``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.NormalizeWhitespace``1(``0,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.NormalizeWhitespace``1(``0,System.String,System.String,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.RemoveNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxRemoveOptions) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.RemoveNodes``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},Microsoft.CodeAnalysis.SyntaxRemoveOptions) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNode``1(``0,Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceNodes``2(``0,System.Collections.Generic.IEnumerable{``1},System.Func{``1,``1,Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceSyntax``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode},System.Func{Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken},System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceToken``1(``0,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceToken``1(``0,Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTokens``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken},System.Func{Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia},System.Func{Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.TrackNodes``1(``0,Microsoft.CodeAnalysis.SyntaxNode[]) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.TrackNodes``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNode}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithLeadingTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutLeadingTrivia``1(``0) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrailingTrivia``1(``0) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrivia(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithoutTrivia``1(``0) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTrailingTrivia``1(``0,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeExtensions.WithTriviaFrom``1(``0,Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.AsNode -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.AsToken -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.ChildNodesAndTokens -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.Equals(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsAnnotations -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsDiagnostics -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_ContainsDirectives -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_HasLeadingTrivia -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_HasTrailingTrivia -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsMissing -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsNode -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_IsToken -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Language -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Parent -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_RawKind -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_Span -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_SpanStart -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.get_SyntaxTree -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetDiagnostics -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetFirstChildIndexSpanningPosition(Microsoft.CodeAnalysis.SyntaxNode,System.Int32) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetLeadingTrivia -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetLocation -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetNextSibling -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetPreviousSibling -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.GetTrailingTrivia -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotations(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.HasAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Equality(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Explicit(Microsoft.CodeAnalysis.SyntaxNodeOrToken)~Microsoft.CodeAnalysis.SyntaxNode -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Explicit(Microsoft.CodeAnalysis.SyntaxNodeOrToken)~Microsoft.CodeAnalysis.SyntaxToken -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Implicit(Microsoft.CodeAnalysis.SyntaxNode)~Microsoft.CodeAnalysis.SyntaxNodeOrToken -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Implicit(Microsoft.CodeAnalysis.SyntaxToken)~Microsoft.CodeAnalysis.SyntaxNodeOrToken -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.op_Inequality(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.ToFullString -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.ToString -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithLeadingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithoutAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WithTrailingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrToken.WriteTo(System.IO.TextWriter) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxNodeOrToken[]) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Add(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Any -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Equals(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.First -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.FirstOrDefault -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Count -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.get_Span -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.GetEnumerator -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.IndexOf(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Last -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.LastOrDefault -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.op_Equality(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList,Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.op_Inequality(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList,Microsoft.CodeAnalysis.SyntaxNodeOrTokenList) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Remove(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.RemoveAt(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Replace(Microsoft.CodeAnalysis.SyntaxNodeOrToken,Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxNodeOrToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxNodeOrToken}) -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ToFullString -M:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.ToString -M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.#ctor(System.Object,System.IntPtr) -M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.BeginInvoke(System.AsyncCallback,System.Object) -M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.EndInvoke(System.IAsyncResult) -M:Microsoft.CodeAnalysis.SyntaxReceiverCreator.Invoke -M:Microsoft.CodeAnalysis.SyntaxReference.#ctor -M:Microsoft.CodeAnalysis.SyntaxReference.get_Span -M:Microsoft.CodeAnalysis.SyntaxReference.get_SyntaxTree -M:Microsoft.CodeAnalysis.SyntaxReference.GetSyntax(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxReference.GetSyntaxAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxToken.CopyAnnotationsTo(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.Equals(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxToken.get_ContainsAnnotations -M:Microsoft.CodeAnalysis.SyntaxToken.get_ContainsDiagnostics -M:Microsoft.CodeAnalysis.SyntaxToken.get_ContainsDirectives -M:Microsoft.CodeAnalysis.SyntaxToken.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxToken.get_HasLeadingTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.get_HasStructuredTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.get_HasTrailingTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.get_IsMissing -M:Microsoft.CodeAnalysis.SyntaxToken.get_Language -M:Microsoft.CodeAnalysis.SyntaxToken.get_LeadingTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.get_Parent -M:Microsoft.CodeAnalysis.SyntaxToken.get_RawKind -M:Microsoft.CodeAnalysis.SyntaxToken.get_Span -M:Microsoft.CodeAnalysis.SyntaxToken.get_SpanStart -M:Microsoft.CodeAnalysis.SyntaxToken.get_SyntaxTree -M:Microsoft.CodeAnalysis.SyntaxToken.get_Text -M:Microsoft.CodeAnalysis.SyntaxToken.get_TrailingTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.get_Value -M:Microsoft.CodeAnalysis.SyntaxToken.get_ValueText -M:Microsoft.CodeAnalysis.SyntaxToken.GetAllTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.Collections.Generic.IEnumerable{System.String}) -M:Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxToken.GetAnnotations(System.String[]) -M:Microsoft.CodeAnalysis.SyntaxToken.GetDiagnostics -M:Microsoft.CodeAnalysis.SyntaxToken.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxToken.GetLocation -M:Microsoft.CodeAnalysis.SyntaxToken.GetNextToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxToken.GetPreviousToken(System.Boolean,System.Boolean,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxToken.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxToken.HasAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxToken.HasAnnotations(System.String[]) -M:Microsoft.CodeAnalysis.SyntaxToken.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.IsPartOfStructuredTrivia -M:Microsoft.CodeAnalysis.SyntaxToken.op_Equality(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.op_Inequality(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.ToFullString -M:Microsoft.CodeAnalysis.SyntaxToken.ToString -M:Microsoft.CodeAnalysis.SyntaxToken.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.SyntaxToken.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxToken.WithLeadingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.SyntaxToken.WithoutAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxToken.WithTrailingTrivia(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxToken.WithTriviaFrom(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxToken.WriteTo(System.IO.TextWriter) -M:Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(Microsoft.CodeAnalysis.SyntaxToken[]) -M:Microsoft.CodeAnalysis.SyntaxTokenList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Add(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Any -M:Microsoft.CodeAnalysis.SyntaxTokenList.Create(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SyntaxTokenList.Equals(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTokenList.First -M:Microsoft.CodeAnalysis.SyntaxTokenList.get_Count -M:Microsoft.CodeAnalysis.SyntaxTokenList.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxTokenList.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxTokenList.get_Span -M:Microsoft.CodeAnalysis.SyntaxTokenList.GetEnumerator -M:Microsoft.CodeAnalysis.SyntaxTokenList.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTokenList.IndexOf(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Last -M:Microsoft.CodeAnalysis.SyntaxTokenList.op_Equality(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.SyntaxTokenList.op_Inequality(Microsoft.CodeAnalysis.SyntaxTokenList,Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Remove(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.RemoveAt(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Replace(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTokenList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxToken,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxToken}) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reverse -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.#ctor(Microsoft.CodeAnalysis.SyntaxTokenList) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Equals(Microsoft.CodeAnalysis.SyntaxTokenList.Reversed) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.GetEnumerator -M:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTokenList.ToFullString -M:Microsoft.CodeAnalysis.SyntaxTokenList.ToString -M:Microsoft.CodeAnalysis.SyntaxTree.#ctor -M:Microsoft.CodeAnalysis.SyntaxTree.get_DiagnosticOptions -M:Microsoft.CodeAnalysis.SyntaxTree.get_Encoding -M:Microsoft.CodeAnalysis.SyntaxTree.get_FilePath -M:Microsoft.CodeAnalysis.SyntaxTree.get_HasCompilationUnitRoot -M:Microsoft.CodeAnalysis.SyntaxTree.get_Length -M:Microsoft.CodeAnalysis.SyntaxTree.get_Options -M:Microsoft.CodeAnalysis.SyntaxTree.get_OptionsCore -M:Microsoft.CodeAnalysis.SyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.SyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree) -M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTree.GetDiagnostics(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetLineMappings(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetLineVisibility(System.Int32,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.SyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetReference(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxTree.GetRoot(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetRootAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetRootCore(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetText(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.GetTextAsync(System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTree.HasHiddenRegions -M:Microsoft.CodeAnalysis.SyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean) -M:Microsoft.CodeAnalysis.SyntaxTree.ToString -M:Microsoft.CodeAnalysis.SyntaxTree.TryGetRoot(Microsoft.CodeAnalysis.SyntaxNode@) -M:Microsoft.CodeAnalysis.SyntaxTree.TryGetRootCore(Microsoft.CodeAnalysis.SyntaxNode@) -M:Microsoft.CodeAnalysis.SyntaxTree.TryGetText(Microsoft.CodeAnalysis.Text.SourceText@) -M:Microsoft.CodeAnalysis.SyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.SyntaxTree.WithDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}) -M:Microsoft.CodeAnalysis.SyntaxTree.WithFilePath(System.String) -M:Microsoft.CodeAnalysis.SyntaxTree.WithRootAndOptions(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions) -M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.#ctor -M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.IsGenerated(Microsoft.CodeAnalysis.SyntaxTree,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.TryGetDiagnosticValue(Microsoft.CodeAnalysis.SyntaxTree,System.String,System.Threading.CancellationToken,Microsoft.CodeAnalysis.ReportDiagnostic@) -M:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider.TryGetGlobalDiagnosticValue(System.String,System.Threading.CancellationToken,Microsoft.CodeAnalysis.ReportDiagnostic@) -M:Microsoft.CodeAnalysis.SyntaxTrivia.CopyAnnotationsTo(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTrivia.Equals(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTrivia.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_ContainsDiagnostics -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_HasStructure -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_IsDirective -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_Language -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_RawKind -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_Span -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_SpanStart -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_SyntaxTree -M:Microsoft.CodeAnalysis.SyntaxTrivia.get_Token -M:Microsoft.CodeAnalysis.SyntaxTrivia.GetAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxTrivia.GetAnnotations(System.String[]) -M:Microsoft.CodeAnalysis.SyntaxTrivia.GetDiagnostics -M:Microsoft.CodeAnalysis.SyntaxTrivia.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTrivia.GetLocation -M:Microsoft.CodeAnalysis.SyntaxTrivia.GetStructure -M:Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotation(Microsoft.CodeAnalysis.SyntaxAnnotation) -M:Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxTrivia.HasAnnotations(System.String[]) -M:Microsoft.CodeAnalysis.SyntaxTrivia.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTrivia.IsPartOfStructuredTrivia -M:Microsoft.CodeAnalysis.SyntaxTrivia.op_Equality(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTrivia.op_Inequality(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTrivia.ToFullString -M:Microsoft.CodeAnalysis.SyntaxTrivia.ToString -M:Microsoft.CodeAnalysis.SyntaxTrivia.WithAdditionalAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.SyntaxTrivia.WithAdditionalAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(Microsoft.CodeAnalysis.SyntaxAnnotation[]) -M:Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxAnnotation}) -M:Microsoft.CodeAnalysis.SyntaxTrivia.WithoutAnnotations(System.String) -M:Microsoft.CodeAnalysis.SyntaxTrivia.WriteTo(System.IO.TextWriter) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(Microsoft.CodeAnalysis.SyntaxTrivia[]) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.#ctor(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Add(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.AddRange(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Any -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Create(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Create(System.ReadOnlySpan{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.ElementAt(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Equals(Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.First -M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Count -M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Empty -M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_FullSpan -M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.get_Span -M:Microsoft.CodeAnalysis.SyntaxTriviaList.GetEnumerator -M:Microsoft.CodeAnalysis.SyntaxTriviaList.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTriviaList.IndexOf(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Insert(System.Int32,Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Last -M:Microsoft.CodeAnalysis.SyntaxTriviaList.op_Equality(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.op_Inequality(Microsoft.CodeAnalysis.SyntaxTriviaList,Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Remove(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.RemoveAt(System.Int32) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Replace(Microsoft.CodeAnalysis.SyntaxTrivia,Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.ReplaceRange(Microsoft.CodeAnalysis.SyntaxTrivia,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.SyntaxTrivia}) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reverse -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.#ctor(Microsoft.CodeAnalysis.SyntaxTriviaList) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator.get_Current -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Equals(Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Equals(System.Object) -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.GetEnumerator -M:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.GetHashCode -M:Microsoft.CodeAnalysis.SyntaxTriviaList.ToFullString -M:Microsoft.CodeAnalysis.SyntaxTriviaList.ToString -M:Microsoft.CodeAnalysis.SyntaxValueProvider.CreateSyntaxProvider``1(System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken,System.Boolean},System.Func{Microsoft.CodeAnalysis.GeneratorSyntaxContext,System.Threading.CancellationToken,``0}) -M:Microsoft.CodeAnalysis.SyntaxValueProvider.ForAttributeWithMetadataName``1(System.String,System.Func{Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken,System.Boolean},System.Func{Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext,System.Threading.CancellationToken,``0}) -M:Microsoft.CodeAnalysis.SyntaxWalker.#ctor(Microsoft.CodeAnalysis.SyntaxWalkerDepth) -M:Microsoft.CodeAnalysis.SyntaxWalker.get_Depth -M:Microsoft.CodeAnalysis.SyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode) -M:Microsoft.CodeAnalysis.SyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken) -M:Microsoft.CodeAnalysis.SyntaxWalker.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia) -M:Microsoft.CodeAnalysis.Text.LinePosition.#ctor(System.Int32,System.Int32) -M:Microsoft.CodeAnalysis.Text.LinePosition.CompareTo(Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.Equals(Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.LinePosition.get_Character -M:Microsoft.CodeAnalysis.Text.LinePosition.get_Line -M:Microsoft.CodeAnalysis.Text.LinePosition.get_Zero -M:Microsoft.CodeAnalysis.Text.LinePosition.GetHashCode -M:Microsoft.CodeAnalysis.Text.LinePosition.op_Equality(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.op_GreaterThan(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.op_GreaterThanOrEqual(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.op_Inequality(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.op_LessThan(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.op_LessThanOrEqual(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePosition.ToString -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.#ctor(Microsoft.CodeAnalysis.Text.LinePosition,Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.Equals(Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.get_End -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.get_Start -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.GetHashCode -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.op_Equality(Microsoft.CodeAnalysis.Text.LinePositionSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.op_Inequality(Microsoft.CodeAnalysis.Text.LinePositionSpan,Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.Text.LinePositionSpan.ToString -M:Microsoft.CodeAnalysis.Text.SourceText.#ctor(System.Collections.Immutable.ImmutableArray{System.Byte},Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,Microsoft.CodeAnalysis.Text.SourceTextContainer) -M:Microsoft.CodeAnalysis.Text.SourceText.ContentEquals(Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.Text.SourceText.ContentEqualsImpl(Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.Text.SourceText.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) -M:Microsoft.CodeAnalysis.Text.SourceText.From(System.Byte[],System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean) -M:Microsoft.CodeAnalysis.Text.SourceText.From(System.Byte[],System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.Stream,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean) -M:Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.Stream,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm,System.Boolean,System.Boolean) -M:Microsoft.CodeAnalysis.Text.SourceText.From(System.IO.TextReader,System.Int32,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) -M:Microsoft.CodeAnalysis.Text.SourceText.From(System.String,System.Text.Encoding,Microsoft.CodeAnalysis.Text.SourceHashAlgorithm) -M:Microsoft.CodeAnalysis.Text.SourceText.get_CanBeEmbedded -M:Microsoft.CodeAnalysis.Text.SourceText.get_ChecksumAlgorithm -M:Microsoft.CodeAnalysis.Text.SourceText.get_Container -M:Microsoft.CodeAnalysis.Text.SourceText.get_Encoding -M:Microsoft.CodeAnalysis.Text.SourceText.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.Text.SourceText.get_Length -M:Microsoft.CodeAnalysis.Text.SourceText.get_Lines -M:Microsoft.CodeAnalysis.Text.SourceText.GetChangeRanges(Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.Text.SourceText.GetChecksum -M:Microsoft.CodeAnalysis.Text.SourceText.GetContentHash -M:Microsoft.CodeAnalysis.Text.SourceText.GetLinesCore -M:Microsoft.CodeAnalysis.Text.SourceText.GetSubText(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.SourceText.GetSubText(System.Int32) -M:Microsoft.CodeAnalysis.Text.SourceText.GetTextChanges(Microsoft.CodeAnalysis.Text.SourceText) -M:Microsoft.CodeAnalysis.Text.SourceText.Replace(Microsoft.CodeAnalysis.Text.TextSpan,System.String) -M:Microsoft.CodeAnalysis.Text.SourceText.Replace(System.Int32,System.Int32,System.String) -M:Microsoft.CodeAnalysis.Text.SourceText.ToString -M:Microsoft.CodeAnalysis.Text.SourceText.ToString(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.SourceText.WithChanges(Microsoft.CodeAnalysis.Text.TextChange[]) -M:Microsoft.CodeAnalysis.Text.SourceText.WithChanges(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChange}) -M:Microsoft.CodeAnalysis.Text.SourceText.Write(System.IO.TextWriter,Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Text.SourceText.Write(System.IO.TextWriter,System.Threading.CancellationToken) -M:Microsoft.CodeAnalysis.Text.SourceTextContainer.#ctor -M:Microsoft.CodeAnalysis.Text.SourceTextContainer.add_TextChanged(System.EventHandler{Microsoft.CodeAnalysis.Text.TextChangeEventArgs}) -M:Microsoft.CodeAnalysis.Text.SourceTextContainer.get_CurrentText -M:Microsoft.CodeAnalysis.Text.SourceTextContainer.remove_TextChanged(System.EventHandler{Microsoft.CodeAnalysis.Text.TextChangeEventArgs}) -M:Microsoft.CodeAnalysis.Text.TextChange.#ctor(Microsoft.CodeAnalysis.Text.TextSpan,System.String) -M:Microsoft.CodeAnalysis.Text.TextChange.Equals(Microsoft.CodeAnalysis.Text.TextChange) -M:Microsoft.CodeAnalysis.Text.TextChange.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.TextChange.get_NewText -M:Microsoft.CodeAnalysis.Text.TextChange.get_NoChanges -M:Microsoft.CodeAnalysis.Text.TextChange.get_Span -M:Microsoft.CodeAnalysis.Text.TextChange.GetHashCode -M:Microsoft.CodeAnalysis.Text.TextChange.op_Equality(Microsoft.CodeAnalysis.Text.TextChange,Microsoft.CodeAnalysis.Text.TextChange) -M:Microsoft.CodeAnalysis.Text.TextChange.op_Implicit(Microsoft.CodeAnalysis.Text.TextChange)~Microsoft.CodeAnalysis.Text.TextChangeRange -M:Microsoft.CodeAnalysis.Text.TextChange.op_Inequality(Microsoft.CodeAnalysis.Text.TextChange,Microsoft.CodeAnalysis.Text.TextChange) -M:Microsoft.CodeAnalysis.Text.TextChange.ToString -M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.#ctor(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.TextChangeRange[]) -M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.#ctor(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.SourceText,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChangeRange}) -M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_Changes -M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_NewText -M:Microsoft.CodeAnalysis.Text.TextChangeEventArgs.get_OldText -M:Microsoft.CodeAnalysis.Text.TextChangeRange.#ctor(Microsoft.CodeAnalysis.Text.TextSpan,System.Int32) -M:Microsoft.CodeAnalysis.Text.TextChangeRange.Collapse(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextChangeRange}) -M:Microsoft.CodeAnalysis.Text.TextChangeRange.Equals(Microsoft.CodeAnalysis.Text.TextChangeRange) -M:Microsoft.CodeAnalysis.Text.TextChangeRange.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.TextChangeRange.get_NewLength -M:Microsoft.CodeAnalysis.Text.TextChangeRange.get_NoChanges -M:Microsoft.CodeAnalysis.Text.TextChangeRange.get_Span -M:Microsoft.CodeAnalysis.Text.TextChangeRange.GetHashCode -M:Microsoft.CodeAnalysis.Text.TextChangeRange.op_Equality(Microsoft.CodeAnalysis.Text.TextChangeRange,Microsoft.CodeAnalysis.Text.TextChangeRange) -M:Microsoft.CodeAnalysis.Text.TextChangeRange.op_Inequality(Microsoft.CodeAnalysis.Text.TextChangeRange,Microsoft.CodeAnalysis.Text.TextChangeRange) -M:Microsoft.CodeAnalysis.Text.TextChangeRange.ToString -M:Microsoft.CodeAnalysis.Text.TextLine.Equals(Microsoft.CodeAnalysis.Text.TextLine) -M:Microsoft.CodeAnalysis.Text.TextLine.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.TextLine.FromSpan(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextLine.get_End -M:Microsoft.CodeAnalysis.Text.TextLine.get_EndIncludingLineBreak -M:Microsoft.CodeAnalysis.Text.TextLine.get_LineNumber -M:Microsoft.CodeAnalysis.Text.TextLine.get_Span -M:Microsoft.CodeAnalysis.Text.TextLine.get_SpanIncludingLineBreak -M:Microsoft.CodeAnalysis.Text.TextLine.get_Start -M:Microsoft.CodeAnalysis.Text.TextLine.get_Text -M:Microsoft.CodeAnalysis.Text.TextLine.GetHashCode -M:Microsoft.CodeAnalysis.Text.TextLine.op_Equality(Microsoft.CodeAnalysis.Text.TextLine,Microsoft.CodeAnalysis.Text.TextLine) -M:Microsoft.CodeAnalysis.Text.TextLine.op_Inequality(Microsoft.CodeAnalysis.Text.TextLine,Microsoft.CodeAnalysis.Text.TextLine) -M:Microsoft.CodeAnalysis.Text.TextLine.ToString -M:Microsoft.CodeAnalysis.Text.TextLineCollection.#ctor -M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.get_Current -M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.GetHashCode -M:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator.MoveNext -M:Microsoft.CodeAnalysis.Text.TextLineCollection.get_Count -M:Microsoft.CodeAnalysis.Text.TextLineCollection.get_Item(System.Int32) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetEnumerator -M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetLineFromPosition(System.Int32) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetLinePosition(System.Int32) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetLinePositionSpan(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetPosition(Microsoft.CodeAnalysis.Text.LinePosition) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.GetTextSpan(Microsoft.CodeAnalysis.Text.LinePositionSpan) -M:Microsoft.CodeAnalysis.Text.TextLineCollection.IndexOf(System.Int32) -M:Microsoft.CodeAnalysis.Text.TextSpan.#ctor(System.Int32,System.Int32) -M:Microsoft.CodeAnalysis.Text.TextSpan.CompareTo(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.Contains(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.Contains(System.Int32) -M:Microsoft.CodeAnalysis.Text.TextSpan.Equals(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.Equals(System.Object) -M:Microsoft.CodeAnalysis.Text.TextSpan.FromBounds(System.Int32,System.Int32) -M:Microsoft.CodeAnalysis.Text.TextSpan.get_End -M:Microsoft.CodeAnalysis.Text.TextSpan.get_IsEmpty -M:Microsoft.CodeAnalysis.Text.TextSpan.get_Length -M:Microsoft.CodeAnalysis.Text.TextSpan.get_Start -M:Microsoft.CodeAnalysis.Text.TextSpan.GetHashCode -M:Microsoft.CodeAnalysis.Text.TextSpan.Intersection(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.IntersectsWith(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.IntersectsWith(System.Int32) -M:Microsoft.CodeAnalysis.Text.TextSpan.op_Equality(Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.op_Inequality(Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.Overlap(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.OverlapsWith(Microsoft.CodeAnalysis.Text.TextSpan) -M:Microsoft.CodeAnalysis.Text.TextSpan.ToString -M:Microsoft.CodeAnalysis.TypedConstant.Equals(Microsoft.CodeAnalysis.TypedConstant) -M:Microsoft.CodeAnalysis.TypedConstant.Equals(System.Object) -M:Microsoft.CodeAnalysis.TypedConstant.get_IsNull -M:Microsoft.CodeAnalysis.TypedConstant.get_Kind -M:Microsoft.CodeAnalysis.TypedConstant.get_Type -M:Microsoft.CodeAnalysis.TypedConstant.get_Value -M:Microsoft.CodeAnalysis.TypedConstant.get_Values -M:Microsoft.CodeAnalysis.TypedConstant.GetHashCode -M:Microsoft.CodeAnalysis.TypeInfo.Equals(Microsoft.CodeAnalysis.TypeInfo) -M:Microsoft.CodeAnalysis.TypeInfo.Equals(System.Object) -M:Microsoft.CodeAnalysis.TypeInfo.get_ConvertedNullability -M:Microsoft.CodeAnalysis.TypeInfo.get_ConvertedType -M:Microsoft.CodeAnalysis.TypeInfo.get_Nullability -M:Microsoft.CodeAnalysis.TypeInfo.get_Type -M:Microsoft.CodeAnalysis.TypeInfo.GetHashCode -M:Microsoft.CodeAnalysis.UnresolvedMetadataReference.get_Display -M:Microsoft.CodeAnalysis.UnresolvedMetadataReference.get_Reference -M:Microsoft.CodeAnalysis.XmlFileResolver.#ctor(System.String) -M:Microsoft.CodeAnalysis.XmlFileResolver.Equals(System.Object) -M:Microsoft.CodeAnalysis.XmlFileResolver.FileExists(System.String) -M:Microsoft.CodeAnalysis.XmlFileResolver.get_BaseDirectory -M:Microsoft.CodeAnalysis.XmlFileResolver.get_Default -M:Microsoft.CodeAnalysis.XmlFileResolver.GetHashCode -M:Microsoft.CodeAnalysis.XmlFileResolver.OpenRead(System.String) -M:Microsoft.CodeAnalysis.XmlFileResolver.ResolveReference(System.String,System.String) -M:Microsoft.CodeAnalysis.XmlReferenceResolver.#ctor -M:Microsoft.CodeAnalysis.XmlReferenceResolver.Equals(System.Object) -M:Microsoft.CodeAnalysis.XmlReferenceResolver.GetHashCode -M:Microsoft.CodeAnalysis.XmlReferenceResolver.OpenRead(System.String) -M:Microsoft.CodeAnalysis.XmlReferenceResolver.ResolveReference(System.String,System.String) -T:Microsoft.CodeAnalysis.Accessibility -T:Microsoft.CodeAnalysis.AdditionalText -T:Microsoft.CodeAnalysis.AnalyzerConfig -T:Microsoft.CodeAnalysis.AnalyzerConfigOptionsResult -T:Microsoft.CodeAnalysis.AnalyzerConfigSet -T:Microsoft.CodeAnalysis.AnnotationExtensions -T:Microsoft.CodeAnalysis.AssemblyIdentity -T:Microsoft.CodeAnalysis.AssemblyIdentityComparer -T:Microsoft.CodeAnalysis.AssemblyIdentityComparer.ComparisonResult -T:Microsoft.CodeAnalysis.AssemblyIdentityParts -T:Microsoft.CodeAnalysis.AssemblyMetadata -T:Microsoft.CodeAnalysis.AttributeData -T:Microsoft.CodeAnalysis.CandidateReason -T:Microsoft.CodeAnalysis.CaseInsensitiveComparison -T:Microsoft.CodeAnalysis.ChildSyntaxList -T:Microsoft.CodeAnalysis.ChildSyntaxList.Enumerator -T:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed -T:Microsoft.CodeAnalysis.ChildSyntaxList.Reversed.Enumerator -T:Microsoft.CodeAnalysis.CommandLineAnalyzerReference -T:Microsoft.CodeAnalysis.CommandLineArguments -T:Microsoft.CodeAnalysis.CommandLineReference -T:Microsoft.CodeAnalysis.CommandLineSourceFile -T:Microsoft.CodeAnalysis.Compilation -T:Microsoft.CodeAnalysis.CompilationOptions -T:Microsoft.CodeAnalysis.CompilationReference -T:Microsoft.CodeAnalysis.ControlFlowAnalysis -T:Microsoft.CodeAnalysis.CustomModifier -T:Microsoft.CodeAnalysis.DataFlowAnalysis -T:Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer -T:Microsoft.CodeAnalysis.Diagnostic -T:Microsoft.CodeAnalysis.DiagnosticDescriptor -T:Microsoft.CodeAnalysis.DiagnosticFormatter -T:Microsoft.CodeAnalysis.Diagnostics.AdditionalFileAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.AdditionalTextValueProvider`1 -T:Microsoft.CodeAnalysis.Diagnostics.AnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.AnalysisResult -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerImageReference -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerLoadFailureEventArgs.FailureErrorCode -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerOptions -T:Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference -T:Microsoft.CodeAnalysis.Diagnostics.CodeBlockAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.CodeBlockStartAnalysisContext`1 -T:Microsoft.CodeAnalysis.Diagnostics.CompilationAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzers -T:Microsoft.CodeAnalysis.Diagnostics.CompilationWithAnalyzersOptions -T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer -T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute -T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions -T:Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor -T:Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags -T:Microsoft.CodeAnalysis.Diagnostics.OperationAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.OperationBlockAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SemanticModelAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SourceTextValueProvider`1 -T:Microsoft.CodeAnalysis.Diagnostics.Suppression -T:Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SuppressionInfo -T:Microsoft.CodeAnalysis.Diagnostics.SymbolAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SymbolStartAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SyntaxNodeAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeAnalysisContext -T:Microsoft.CodeAnalysis.Diagnostics.SyntaxTreeValueProvider`1 -T:Microsoft.CodeAnalysis.Diagnostics.Telemetry.AnalyzerTelemetryInfo -T:Microsoft.CodeAnalysis.Diagnostics.UnresolvedAnalyzerReference -T:Microsoft.CodeAnalysis.DiagnosticSeverity -T:Microsoft.CodeAnalysis.DllImportData -T:Microsoft.CodeAnalysis.DocumentationCommentId -T:Microsoft.CodeAnalysis.DocumentationMode -T:Microsoft.CodeAnalysis.DocumentationProvider -T:Microsoft.CodeAnalysis.EmbeddedText -T:Microsoft.CodeAnalysis.Emit.DebugInformationFormat -T:Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation -T:Microsoft.CodeAnalysis.Emit.EmitBaseline -T:Microsoft.CodeAnalysis.Emit.EmitDifferenceResult -T:Microsoft.CodeAnalysis.Emit.EmitOptions -T:Microsoft.CodeAnalysis.Emit.EmitResult -T:Microsoft.CodeAnalysis.Emit.InstrumentationKind -T:Microsoft.CodeAnalysis.Emit.MethodInstrumentation -T:Microsoft.CodeAnalysis.Emit.RuntimeRudeEdit -T:Microsoft.CodeAnalysis.Emit.SemanticEdit -T:Microsoft.CodeAnalysis.Emit.SemanticEditKind -T:Microsoft.CodeAnalysis.ErrorLogOptions -T:Microsoft.CodeAnalysis.FileLinePositionSpan -T:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlock -T:Microsoft.CodeAnalysis.FlowAnalysis.BasicBlockKind -T:Microsoft.CodeAnalysis.FlowAnalysis.CaptureId -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranch -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowBranchSemantics -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowConditionKind -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraph -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowGraphExtensions -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegion -T:Microsoft.CodeAnalysis.FlowAnalysis.ControlFlowRegionKind -T:Microsoft.CodeAnalysis.FlowAnalysis.ICaughtExceptionOperation -T:Microsoft.CodeAnalysis.FlowAnalysis.IFlowAnonymousFunctionOperation -T:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureOperation -T:Microsoft.CodeAnalysis.FlowAnalysis.IFlowCaptureReferenceOperation -T:Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation -T:Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation -T:Microsoft.CodeAnalysis.GeneratedKind -T:Microsoft.CodeAnalysis.GeneratedSourceResult -T:Microsoft.CodeAnalysis.GeneratorAttribute -T:Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext -T:Microsoft.CodeAnalysis.GeneratorDriver -T:Microsoft.CodeAnalysis.GeneratorDriverOptions -T:Microsoft.CodeAnalysis.GeneratorDriverRunResult -T:Microsoft.CodeAnalysis.GeneratorDriverTimingInfo -T:Microsoft.CodeAnalysis.GeneratorExecutionContext -T:Microsoft.CodeAnalysis.GeneratorExtensions -T:Microsoft.CodeAnalysis.GeneratorInitializationContext -T:Microsoft.CodeAnalysis.GeneratorPostInitializationContext -T:Microsoft.CodeAnalysis.GeneratorRunResult -T:Microsoft.CodeAnalysis.GeneratorSyntaxContext -T:Microsoft.CodeAnalysis.GeneratorTimingInfo -T:Microsoft.CodeAnalysis.IAliasSymbol -T:Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader -T:Microsoft.CodeAnalysis.IArrayTypeSymbol -T:Microsoft.CodeAnalysis.IAssemblySymbol -T:Microsoft.CodeAnalysis.ICompilationUnitSyntax -T:Microsoft.CodeAnalysis.IDiscardSymbol -T:Microsoft.CodeAnalysis.IDynamicTypeSymbol -T:Microsoft.CodeAnalysis.IErrorTypeSymbol -T:Microsoft.CodeAnalysis.IEventSymbol -T:Microsoft.CodeAnalysis.IFieldSymbol -T:Microsoft.CodeAnalysis.IFunctionPointerTypeSymbol -T:Microsoft.CodeAnalysis.IImportScope -T:Microsoft.CodeAnalysis.IIncrementalGenerator -T:Microsoft.CodeAnalysis.ILabelSymbol -T:Microsoft.CodeAnalysis.ILocalSymbol -T:Microsoft.CodeAnalysis.IMethodSymbol -T:Microsoft.CodeAnalysis.IModuleSymbol -T:Microsoft.CodeAnalysis.ImportedNamespaceOrType -T:Microsoft.CodeAnalysis.ImportedXmlNamespace -T:Microsoft.CodeAnalysis.INamedTypeSymbol -T:Microsoft.CodeAnalysis.INamespaceOrTypeSymbol -T:Microsoft.CodeAnalysis.INamespaceSymbol -T:Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext -T:Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind -T:Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext -T:Microsoft.CodeAnalysis.IncrementalGeneratorRunStep -T:Microsoft.CodeAnalysis.IncrementalStepRunReason -T:Microsoft.CodeAnalysis.IncrementalValueProvider`1 -T:Microsoft.CodeAnalysis.IncrementalValueProviderExtensions -T:Microsoft.CodeAnalysis.IncrementalValuesProvider`1 -T:Microsoft.CodeAnalysis.IOperation -T:Microsoft.CodeAnalysis.IOperation.OperationList -T:Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator -T:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed -T:Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator -T:Microsoft.CodeAnalysis.IParameterSymbol -T:Microsoft.CodeAnalysis.IPointerTypeSymbol -T:Microsoft.CodeAnalysis.IPreprocessingSymbol -T:Microsoft.CodeAnalysis.IPropertySymbol -T:Microsoft.CodeAnalysis.IRangeVariableSymbol -T:Microsoft.CodeAnalysis.ISkippedTokensTriviaSyntax -T:Microsoft.CodeAnalysis.ISourceAssemblySymbol -T:Microsoft.CodeAnalysis.ISourceGenerator -T:Microsoft.CodeAnalysis.IStructuredTriviaSyntax -T:Microsoft.CodeAnalysis.ISymbol -T:Microsoft.CodeAnalysis.ISymbolExtensions -T:Microsoft.CodeAnalysis.ISyntaxContextReceiver -T:Microsoft.CodeAnalysis.ISyntaxReceiver -T:Microsoft.CodeAnalysis.ITypeParameterSymbol -T:Microsoft.CodeAnalysis.ITypeSymbol -T:Microsoft.CodeAnalysis.LanguageNames -T:Microsoft.CodeAnalysis.LineMapping -T:Microsoft.CodeAnalysis.LineVisibility -T:Microsoft.CodeAnalysis.LocalizableResourceString -T:Microsoft.CodeAnalysis.LocalizableString -T:Microsoft.CodeAnalysis.Location -T:Microsoft.CodeAnalysis.LocationKind -T:Microsoft.CodeAnalysis.Metadata -T:Microsoft.CodeAnalysis.MetadataId -T:Microsoft.CodeAnalysis.MetadataImageKind -T:Microsoft.CodeAnalysis.MetadataImportOptions -T:Microsoft.CodeAnalysis.MetadataReference -T:Microsoft.CodeAnalysis.MetadataReferenceProperties -T:Microsoft.CodeAnalysis.MetadataReferenceResolver -T:Microsoft.CodeAnalysis.MethodKind -T:Microsoft.CodeAnalysis.ModelExtensions -T:Microsoft.CodeAnalysis.ModuleMetadata -T:Microsoft.CodeAnalysis.NamespaceKind -T:Microsoft.CodeAnalysis.NullabilityInfo -T:Microsoft.CodeAnalysis.NullableAnnotation -T:Microsoft.CodeAnalysis.NullableContext -T:Microsoft.CodeAnalysis.NullableContextExtensions -T:Microsoft.CodeAnalysis.NullableContextOptions -T:Microsoft.CodeAnalysis.NullableContextOptionsExtensions -T:Microsoft.CodeAnalysis.NullableFlowState -T:Microsoft.CodeAnalysis.OperationKind -T:Microsoft.CodeAnalysis.Operations.ArgumentKind -T:Microsoft.CodeAnalysis.Operations.BinaryOperatorKind -T:Microsoft.CodeAnalysis.Operations.BranchKind -T:Microsoft.CodeAnalysis.Operations.CaseKind -T:Microsoft.CodeAnalysis.Operations.CommonConversion -T:Microsoft.CodeAnalysis.Operations.IAddressOfOperation -T:Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation -T:Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation -T:Microsoft.CodeAnalysis.Operations.IArgumentOperation -T:Microsoft.CodeAnalysis.Operations.IArrayCreationOperation -T:Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IAssignmentOperation -T:Microsoft.CodeAnalysis.Operations.IAttributeOperation -T:Microsoft.CodeAnalysis.Operations.IAwaitOperation -T:Microsoft.CodeAnalysis.Operations.IBinaryOperation -T:Microsoft.CodeAnalysis.Operations.IBinaryPatternOperation -T:Microsoft.CodeAnalysis.Operations.IBlockOperation -T:Microsoft.CodeAnalysis.Operations.IBranchOperation -T:Microsoft.CodeAnalysis.Operations.ICaseClauseOperation -T:Microsoft.CodeAnalysis.Operations.ICatchClauseOperation -T:Microsoft.CodeAnalysis.Operations.ICoalesceAssignmentOperation -T:Microsoft.CodeAnalysis.Operations.ICoalesceOperation -T:Microsoft.CodeAnalysis.Operations.ICollectionElementInitializerOperation -T:Microsoft.CodeAnalysis.Operations.ICollectionExpressionOperation -T:Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation -T:Microsoft.CodeAnalysis.Operations.IConditionalAccessInstanceOperation -T:Microsoft.CodeAnalysis.Operations.IConditionalAccessOperation -T:Microsoft.CodeAnalysis.Operations.IConditionalOperation -T:Microsoft.CodeAnalysis.Operations.IConstantPatternOperation -T:Microsoft.CodeAnalysis.Operations.IConstructorBodyOperation -T:Microsoft.CodeAnalysis.Operations.IConversionOperation -T:Microsoft.CodeAnalysis.Operations.IDeclarationExpressionOperation -T:Microsoft.CodeAnalysis.Operations.IDeclarationPatternOperation -T:Microsoft.CodeAnalysis.Operations.IDeconstructionAssignmentOperation -T:Microsoft.CodeAnalysis.Operations.IDefaultCaseClauseOperation -T:Microsoft.CodeAnalysis.Operations.IDefaultValueOperation -T:Microsoft.CodeAnalysis.Operations.IDelegateCreationOperation -T:Microsoft.CodeAnalysis.Operations.IDiscardOperation -T:Microsoft.CodeAnalysis.Operations.IDiscardPatternOperation -T:Microsoft.CodeAnalysis.Operations.IDynamicIndexerAccessOperation -T:Microsoft.CodeAnalysis.Operations.IDynamicInvocationOperation -T:Microsoft.CodeAnalysis.Operations.IDynamicMemberReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IDynamicObjectCreationOperation -T:Microsoft.CodeAnalysis.Operations.IEmptyOperation -T:Microsoft.CodeAnalysis.Operations.IEndOperation -T:Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation -T:Microsoft.CodeAnalysis.Operations.IEventReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IExpressionStatementOperation -T:Microsoft.CodeAnalysis.Operations.IFieldInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IFieldReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IForEachLoopOperation -T:Microsoft.CodeAnalysis.Operations.IForLoopOperation -T:Microsoft.CodeAnalysis.Operations.IForToLoopOperation -T:Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation -T:Microsoft.CodeAnalysis.Operations.IImplicitIndexerReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IIncrementOrDecrementOperation -T:Microsoft.CodeAnalysis.Operations.IInlineArrayAccessOperation -T:Microsoft.CodeAnalysis.Operations.IInstanceReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAdditionOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringAppendOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringContentOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerArgumentPlaceholderOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringHandlerCreationOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolatedStringTextOperation -T:Microsoft.CodeAnalysis.Operations.IInterpolationOperation -T:Microsoft.CodeAnalysis.Operations.IInvalidOperation -T:Microsoft.CodeAnalysis.Operations.IInvocationOperation -T:Microsoft.CodeAnalysis.Operations.IIsPatternOperation -T:Microsoft.CodeAnalysis.Operations.IIsTypeOperation -T:Microsoft.CodeAnalysis.Operations.ILabeledOperation -T:Microsoft.CodeAnalysis.Operations.IListPatternOperation -T:Microsoft.CodeAnalysis.Operations.ILiteralOperation -T:Microsoft.CodeAnalysis.Operations.ILocalFunctionOperation -T:Microsoft.CodeAnalysis.Operations.ILocalReferenceOperation -T:Microsoft.CodeAnalysis.Operations.ILockOperation -T:Microsoft.CodeAnalysis.Operations.ILoopOperation -T:Microsoft.CodeAnalysis.Operations.IMemberInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IMemberReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IMethodBodyBaseOperation -T:Microsoft.CodeAnalysis.Operations.IMethodBodyOperation -T:Microsoft.CodeAnalysis.Operations.IMethodReferenceOperation -T:Microsoft.CodeAnalysis.Operations.INameOfOperation -T:Microsoft.CodeAnalysis.Operations.INegatedPatternOperation -T:Microsoft.CodeAnalysis.Operations.InstanceReferenceKind -T:Microsoft.CodeAnalysis.Operations.InterpolatedStringArgumentPlaceholderKind -T:Microsoft.CodeAnalysis.Operations.IObjectCreationOperation -T:Microsoft.CodeAnalysis.Operations.IObjectOrCollectionInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IOmittedArgumentOperation -T:Microsoft.CodeAnalysis.Operations.IParameterInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IParameterReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IParenthesizedOperation -T:Microsoft.CodeAnalysis.Operations.IPatternCaseClauseOperation -T:Microsoft.CodeAnalysis.Operations.IPatternOperation -T:Microsoft.CodeAnalysis.Operations.IPropertyInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IPropertyReferenceOperation -T:Microsoft.CodeAnalysis.Operations.IPropertySubpatternOperation -T:Microsoft.CodeAnalysis.Operations.IRaiseEventOperation -T:Microsoft.CodeAnalysis.Operations.IRangeCaseClauseOperation -T:Microsoft.CodeAnalysis.Operations.IRangeOperation -T:Microsoft.CodeAnalysis.Operations.IRecursivePatternOperation -T:Microsoft.CodeAnalysis.Operations.IReDimClauseOperation -T:Microsoft.CodeAnalysis.Operations.IReDimOperation -T:Microsoft.CodeAnalysis.Operations.IRelationalCaseClauseOperation -T:Microsoft.CodeAnalysis.Operations.IRelationalPatternOperation -T:Microsoft.CodeAnalysis.Operations.IReturnOperation -T:Microsoft.CodeAnalysis.Operations.ISimpleAssignmentOperation -T:Microsoft.CodeAnalysis.Operations.ISingleValueCaseClauseOperation -T:Microsoft.CodeAnalysis.Operations.ISizeOfOperation -T:Microsoft.CodeAnalysis.Operations.ISlicePatternOperation -T:Microsoft.CodeAnalysis.Operations.ISpreadOperation -T:Microsoft.CodeAnalysis.Operations.IStopOperation -T:Microsoft.CodeAnalysis.Operations.ISwitchCaseOperation -T:Microsoft.CodeAnalysis.Operations.ISwitchExpressionArmOperation -T:Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation -T:Microsoft.CodeAnalysis.Operations.ISwitchOperation -T:Microsoft.CodeAnalysis.Operations.ISymbolInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IThrowOperation -T:Microsoft.CodeAnalysis.Operations.ITranslatedQueryOperation -T:Microsoft.CodeAnalysis.Operations.ITryOperation -T:Microsoft.CodeAnalysis.Operations.ITupleBinaryOperation -T:Microsoft.CodeAnalysis.Operations.ITupleOperation -T:Microsoft.CodeAnalysis.Operations.ITypeOfOperation -T:Microsoft.CodeAnalysis.Operations.ITypeParameterObjectCreationOperation -T:Microsoft.CodeAnalysis.Operations.ITypePatternOperation -T:Microsoft.CodeAnalysis.Operations.IUnaryOperation -T:Microsoft.CodeAnalysis.Operations.IUsingDeclarationOperation -T:Microsoft.CodeAnalysis.Operations.IUsingOperation -T:Microsoft.CodeAnalysis.Operations.IUtf8StringOperation -T:Microsoft.CodeAnalysis.Operations.IVariableDeclarationGroupOperation -T:Microsoft.CodeAnalysis.Operations.IVariableDeclarationOperation -T:Microsoft.CodeAnalysis.Operations.IVariableDeclaratorOperation -T:Microsoft.CodeAnalysis.Operations.IVariableInitializerOperation -T:Microsoft.CodeAnalysis.Operations.IWhileLoopOperation -T:Microsoft.CodeAnalysis.Operations.IWithOperation -T:Microsoft.CodeAnalysis.Operations.LoopKind -T:Microsoft.CodeAnalysis.Operations.OperationExtensions -T:Microsoft.CodeAnalysis.Operations.OperationVisitor -T:Microsoft.CodeAnalysis.Operations.OperationVisitor`2 -T:Microsoft.CodeAnalysis.Operations.OperationWalker -T:Microsoft.CodeAnalysis.Operations.OperationWalker`1 -T:Microsoft.CodeAnalysis.Operations.UnaryOperatorKind -T:Microsoft.CodeAnalysis.OptimizationLevel -T:Microsoft.CodeAnalysis.Optional`1 -T:Microsoft.CodeAnalysis.OutputKind -T:Microsoft.CodeAnalysis.ParseOptions -T:Microsoft.CodeAnalysis.Platform -T:Microsoft.CodeAnalysis.PortableExecutableReference -T:Microsoft.CodeAnalysis.PreprocessingSymbolInfo -T:Microsoft.CodeAnalysis.RefKind -T:Microsoft.CodeAnalysis.ReportDiagnostic -T:Microsoft.CodeAnalysis.ResourceDescription -T:Microsoft.CodeAnalysis.RuleSet -T:Microsoft.CodeAnalysis.RuleSetInclude -T:Microsoft.CodeAnalysis.RuntimeCapability -T:Microsoft.CodeAnalysis.SarifVersion -T:Microsoft.CodeAnalysis.SarifVersionFacts -T:Microsoft.CodeAnalysis.ScopedKind -T:Microsoft.CodeAnalysis.ScriptCompilationInfo -T:Microsoft.CodeAnalysis.SemanticModel -T:Microsoft.CodeAnalysis.SemanticModelOptions -T:Microsoft.CodeAnalysis.SeparatedSyntaxList -T:Microsoft.CodeAnalysis.SeparatedSyntaxList`1 -T:Microsoft.CodeAnalysis.SeparatedSyntaxList`1.Enumerator -T:Microsoft.CodeAnalysis.SourceCodeKind -T:Microsoft.CodeAnalysis.SourceFileResolver -T:Microsoft.CodeAnalysis.SourceProductionContext -T:Microsoft.CodeAnalysis.SourceReferenceResolver -T:Microsoft.CodeAnalysis.SpecialType -T:Microsoft.CodeAnalysis.SpeculativeBindingOption -T:Microsoft.CodeAnalysis.StrongNameProvider -T:Microsoft.CodeAnalysis.SubsystemVersion -T:Microsoft.CodeAnalysis.SuppressionDescriptor -T:Microsoft.CodeAnalysis.SymbolDisplayDelegateStyle -T:Microsoft.CodeAnalysis.SymbolDisplayExtensionMethodStyle -T:Microsoft.CodeAnalysis.SymbolDisplayExtensions -T:Microsoft.CodeAnalysis.SymbolDisplayFormat -T:Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions -T:Microsoft.CodeAnalysis.SymbolDisplayGlobalNamespaceStyle -T:Microsoft.CodeAnalysis.SymbolDisplayKindOptions -T:Microsoft.CodeAnalysis.SymbolDisplayLocalOptions -T:Microsoft.CodeAnalysis.SymbolDisplayMemberOptions -T:Microsoft.CodeAnalysis.SymbolDisplayMiscellaneousOptions -T:Microsoft.CodeAnalysis.SymbolDisplayParameterOptions -T:Microsoft.CodeAnalysis.SymbolDisplayPart -T:Microsoft.CodeAnalysis.SymbolDisplayPartKind -T:Microsoft.CodeAnalysis.SymbolDisplayPropertyStyle -T:Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle -T:Microsoft.CodeAnalysis.SymbolEqualityComparer -T:Microsoft.CodeAnalysis.SymbolFilter -T:Microsoft.CodeAnalysis.SymbolInfo -T:Microsoft.CodeAnalysis.SymbolKind -T:Microsoft.CodeAnalysis.SymbolVisitor -T:Microsoft.CodeAnalysis.SymbolVisitor`1 -T:Microsoft.CodeAnalysis.SymbolVisitor`2 -T:Microsoft.CodeAnalysis.SyntaxAnnotation -T:Microsoft.CodeAnalysis.SyntaxContextReceiverCreator -T:Microsoft.CodeAnalysis.SyntaxList -T:Microsoft.CodeAnalysis.SyntaxList`1 -T:Microsoft.CodeAnalysis.SyntaxList`1.Enumerator -T:Microsoft.CodeAnalysis.SyntaxNode -T:Microsoft.CodeAnalysis.SyntaxNodeExtensions -T:Microsoft.CodeAnalysis.SyntaxNodeOrToken -T:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList -T:Microsoft.CodeAnalysis.SyntaxNodeOrTokenList.Enumerator -T:Microsoft.CodeAnalysis.SyntaxReceiverCreator -T:Microsoft.CodeAnalysis.SyntaxReference -T:Microsoft.CodeAnalysis.SyntaxRemoveOptions -T:Microsoft.CodeAnalysis.SyntaxToken -T:Microsoft.CodeAnalysis.SyntaxTokenList -T:Microsoft.CodeAnalysis.SyntaxTokenList.Enumerator -T:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed -T:Microsoft.CodeAnalysis.SyntaxTokenList.Reversed.Enumerator -T:Microsoft.CodeAnalysis.SyntaxTree -T:Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider -T:Microsoft.CodeAnalysis.SyntaxTrivia -T:Microsoft.CodeAnalysis.SyntaxTriviaList -T:Microsoft.CodeAnalysis.SyntaxTriviaList.Enumerator -T:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed -T:Microsoft.CodeAnalysis.SyntaxTriviaList.Reversed.Enumerator -T:Microsoft.CodeAnalysis.SyntaxValueProvider -T:Microsoft.CodeAnalysis.SyntaxWalker -T:Microsoft.CodeAnalysis.SyntaxWalkerDepth -T:Microsoft.CodeAnalysis.Text.LinePosition -T:Microsoft.CodeAnalysis.Text.LinePositionSpan -T:Microsoft.CodeAnalysis.Text.SourceHashAlgorithm -T:Microsoft.CodeAnalysis.Text.SourceText -T:Microsoft.CodeAnalysis.Text.SourceTextContainer -T:Microsoft.CodeAnalysis.Text.TextChange -T:Microsoft.CodeAnalysis.Text.TextChangeEventArgs -T:Microsoft.CodeAnalysis.Text.TextChangeRange -T:Microsoft.CodeAnalysis.Text.TextLine -T:Microsoft.CodeAnalysis.Text.TextLineCollection -T:Microsoft.CodeAnalysis.Text.TextLineCollection.Enumerator -T:Microsoft.CodeAnalysis.Text.TextSpan -T:Microsoft.CodeAnalysis.TypedConstant -T:Microsoft.CodeAnalysis.TypedConstantKind -T:Microsoft.CodeAnalysis.TypeInfo -T:Microsoft.CodeAnalysis.TypeKind -T:Microsoft.CodeAnalysis.TypeParameterKind -T:Microsoft.CodeAnalysis.UnresolvedMetadataReference -T:Microsoft.CodeAnalysis.VarianceKind -T:Microsoft.CodeAnalysis.WellKnownDiagnosticTags -T:Microsoft.CodeAnalysis.WellKnownGeneratorInputs -T:Microsoft.CodeAnalysis.WellKnownGeneratorOutputs -T:Microsoft.CodeAnalysis.WellKnownMemberNames -T:Microsoft.CodeAnalysis.XmlFileResolver -T:Microsoft.CodeAnalysis.XmlReferenceResolver \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt deleted file mode 100644 index cca2b21a94568..0000000000000 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.Immutable.txt +++ /dev/null @@ -1,783 +0,0 @@ -F:System.Collections.Immutable.ImmutableArray`1.Empty -F:System.Collections.Immutable.ImmutableDictionary`2.Empty -F:System.Collections.Immutable.ImmutableHashSet`1.Empty -F:System.Collections.Immutable.ImmutableList`1.Empty -F:System.Collections.Immutable.ImmutableSortedDictionary`2.Empty -F:System.Collections.Immutable.ImmutableSortedSet`1.Empty -M:System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Frozen.FrozenDictionary.ToFrozenDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Frozen.FrozenDictionary`2.ContainsKey(`0) -M:System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) -M:System.Collections.Frozen.FrozenDictionary`2.CopyTo(System.Span{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Frozen.FrozenDictionary`2.Enumerator.get_Current -M:System.Collections.Frozen.FrozenDictionary`2.Enumerator.MoveNext -M:System.Collections.Frozen.FrozenDictionary`2.get_Comparer -M:System.Collections.Frozen.FrozenDictionary`2.get_Count -M:System.Collections.Frozen.FrozenDictionary`2.get_Empty -M:System.Collections.Frozen.FrozenDictionary`2.get_Item(`0) -M:System.Collections.Frozen.FrozenDictionary`2.get_Keys -M:System.Collections.Frozen.FrozenDictionary`2.get_Values -M:System.Collections.Frozen.FrozenDictionary`2.GetEnumerator -M:System.Collections.Frozen.FrozenDictionary`2.GetValueRefOrNullRef(`0) -M:System.Collections.Frozen.FrozenDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Frozen.FrozenSet.ToFrozenSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Frozen.FrozenSet`1.Contains(`0) -M:System.Collections.Frozen.FrozenSet`1.CopyTo(`0[],System.Int32) -M:System.Collections.Frozen.FrozenSet`1.CopyTo(System.Span{`0}) -M:System.Collections.Frozen.FrozenSet`1.Enumerator.get_Current -M:System.Collections.Frozen.FrozenSet`1.Enumerator.MoveNext -M:System.Collections.Frozen.FrozenSet`1.get_Comparer -M:System.Collections.Frozen.FrozenSet`1.get_Count -M:System.Collections.Frozen.FrozenSet`1.get_Empty -M:System.Collections.Frozen.FrozenSet`1.get_Items -M:System.Collections.Frozen.FrozenSet`1.GetEnumerator -M:System.Collections.Frozen.FrozenSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Frozen.FrozenSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Frozen.FrozenSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Frozen.FrozenSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Frozen.FrozenSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Frozen.FrozenSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Frozen.FrozenSet`1.TryGetValue(`0,`0@) -M:System.Collections.Immutable.IImmutableDictionary`2.Add(`0,`1) -M:System.Collections.Immutable.IImmutableDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.IImmutableDictionary`2.Clear -M:System.Collections.Immutable.IImmutableDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.IImmutableDictionary`2.Remove(`0) -M:System.Collections.Immutable.IImmutableDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableDictionary`2.SetItem(`0,`1) -M:System.Collections.Immutable.IImmutableDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.IImmutableDictionary`2.TryGetKey(`0,`0@) -M:System.Collections.Immutable.IImmutableList`1.Add(`0) -M:System.Collections.Immutable.IImmutableList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableList`1.Clear -M:System.Collections.Immutable.IImmutableList`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.IImmutableList`1.Insert(System.Int32,`0) -M:System.Collections.Immutable.IImmutableList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableList`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.IImmutableList`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.IImmutableList`1.RemoveAll(System.Predicate{`0}) -M:System.Collections.Immutable.IImmutableList`1.RemoveAt(System.Int32) -M:System.Collections.Immutable.IImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.IImmutableList`1.RemoveRange(System.Int32,System.Int32) -M:System.Collections.Immutable.IImmutableList`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.IImmutableList`1.SetItem(System.Int32,`0) -M:System.Collections.Immutable.IImmutableQueue`1.Clear -M:System.Collections.Immutable.IImmutableQueue`1.Dequeue -M:System.Collections.Immutable.IImmutableQueue`1.Enqueue(`0) -M:System.Collections.Immutable.IImmutableQueue`1.get_IsEmpty -M:System.Collections.Immutable.IImmutableQueue`1.Peek -M:System.Collections.Immutable.IImmutableSet`1.Add(`0) -M:System.Collections.Immutable.IImmutableSet`1.Clear -M:System.Collections.Immutable.IImmutableSet`1.Contains(`0) -M:System.Collections.Immutable.IImmutableSet`1.Except(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.Remove(`0) -M:System.Collections.Immutable.IImmutableSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableSet`1.TryGetValue(`0,`0@) -M:System.Collections.Immutable.IImmutableSet`1.Union(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.IImmutableStack`1.Clear -M:System.Collections.Immutable.IImmutableStack`1.get_IsEmpty -M:System.Collections.Immutable.IImmutableStack`1.Peek -M:System.Collections.Immutable.IImmutableStack`1.Pop -M:System.Collections.Immutable.IImmutableStack`1.Push(`0) -M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},``0) -M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},``0,System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,``0) -M:System.Collections.Immutable.ImmutableArray.BinarySearch``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,``0,System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableArray.Create``1 -M:System.Collections.Immutable.ImmutableArray.Create``1(``0) -M:System.Collections.Immutable.ImmutableArray.Create``1(``0,``0) -M:System.Collections.Immutable.ImmutableArray.Create``1(``0,``0,``0) -M:System.Collections.Immutable.ImmutableArray.Create``1(``0,``0,``0,``0) -M:System.Collections.Immutable.ImmutableArray.Create``1(``0[]) -M:System.Collections.Immutable.ImmutableArray.Create``1(``0[],System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray.Create``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray.Create``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableArray.Create``1(System.Span{``0}) -M:System.Collections.Immutable.ImmutableArray.CreateBuilder``1 -M:System.Collections.Immutable.ImmutableArray.CreateBuilder``1(System.Int32) -M:System.Collections.Immutable.ImmutableArray.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableArray.CreateRange``2(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1}) -M:System.Collections.Immutable.ImmutableArray.CreateRange``2(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,System.Func{``0,``1}) -M:System.Collections.Immutable.ImmutableArray.CreateRange``3(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1,``2},``1) -M:System.Collections.Immutable.ImmutableArray.CreateRange``3(System.Collections.Immutable.ImmutableArray{``0},System.Int32,System.Int32,System.Func{``0,``1,``2},``1) -M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableArray.ToImmutableArray``1(System.Span{``0}) -M:System.Collections.Immutable.ImmutableArray`1.Add(`0) -M:System.Collections.Immutable.ImmutableArray`1.AddRange(`0[]) -M:System.Collections.Immutable.ImmutableArray`1.AddRange(`0[],System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.Collections.Immutable.ImmutableArray{`0},System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.AddRange(System.ReadOnlySpan{`0}) -M:System.Collections.Immutable.ImmutableArray`1.AddRange``1(``0[]) -M:System.Collections.Immutable.ImmutableArray`1.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Collections.Immutable.ImmutableArray`1.As``1 -M:System.Collections.Immutable.ImmutableArray`1.AsMemory -M:System.Collections.Immutable.ImmutableArray`1.AsSpan -M:System.Collections.Immutable.ImmutableArray`1.AsSpan(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.AsSpan(System.Range) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Add(`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(`0[]) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(`0[],System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0},System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.Collections.Immutable.ImmutableArray{`0}.Builder) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange(System.ReadOnlySpan{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(``0[]) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Collections.Immutable.ImmutableArray`1.Builder.AddRange``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Clear -M:System.Collections.Immutable.ImmutableArray`1.Builder.Contains(`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(`0[]) -M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(`0[],System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(System.Int32,`0[],System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.CopyTo(System.Span{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.DrainToImmutable -M:System.Collections.Immutable.ImmutableArray`1.Builder.get_Capacity -M:System.Collections.Immutable.ImmutableArray`1.Builder.get_Count -M:System.Collections.Immutable.ImmutableArray`1.Builder.get_Item(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.GetEnumerator -M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Insert(System.Int32,`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.InsertRange(System.Int32,System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.ItemRef(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.MoveToImmutable -M:System.Collections.Immutable.ImmutableArray`1.Builder.Remove(`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveAt(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.RemoveRange(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Replace(`0,`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Reverse -M:System.Collections.Immutable.ImmutableArray`1.Builder.set_Capacity(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.set_Count(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Builder.set_Item(System.Int32,`0) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort -M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Comparison{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Builder.ToArray -M:System.Collections.Immutable.ImmutableArray`1.Builder.ToImmutable -M:System.Collections.Immutable.ImmutableArray`1.CastArray``1 -M:System.Collections.Immutable.ImmutableArray`1.CastUp``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Collections.Immutable.ImmutableArray`1.Clear -M:System.Collections.Immutable.ImmutableArray`1.Contains(`0) -M:System.Collections.Immutable.ImmutableArray`1.Contains(`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.CopyTo(`0[]) -M:System.Collections.Immutable.ImmutableArray`1.CopyTo(`0[],System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.CopyTo(System.Span{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableArray`1.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableArray`1.Equals(System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Equals(System.Object) -M:System.Collections.Immutable.ImmutableArray`1.get_IsDefault -M:System.Collections.Immutable.ImmutableArray`1.get_IsDefaultOrEmpty -M:System.Collections.Immutable.ImmutableArray`1.get_IsEmpty -M:System.Collections.Immutable.ImmutableArray`1.get_Item(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.get_Length -M:System.Collections.Immutable.ImmutableArray`1.GetEnumerator -M:System.Collections.Immutable.ImmutableArray`1.GetHashCode -M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0) -M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Insert(System.Int32,`0) -M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,`0[]) -M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.InsertRange(System.Int32,System.ReadOnlySpan{`0}) -M:System.Collections.Immutable.ImmutableArray`1.ItemRef(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0) -M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.OfType``1 -M:System.Collections.Immutable.ImmutableArray`1.op_Equality(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.op_Equality(System.Nullable{System.Collections.Immutable.ImmutableArray{`0}},System.Nullable{System.Collections.Immutable.ImmutableArray{`0}}) -M:System.Collections.Immutable.ImmutableArray`1.op_Inequality(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.op_Inequality(System.Nullable{System.Collections.Immutable.ImmutableArray{`0}},System.Nullable{System.Collections.Immutable.ImmutableArray{`0}}) -M:System.Collections.Immutable.ImmutableArray`1.Remove(`0) -M:System.Collections.Immutable.ImmutableArray`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveAt(System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(`0[],System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Immutable.ImmutableArray{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Collections.Immutable.ImmutableArray{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.RemoveRange(System.ReadOnlySpan{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Replace(`0,`0) -M:System.Collections.Immutable.ImmutableArray`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.SetItem(System.Int32,`0) -M:System.Collections.Immutable.ImmutableArray`1.Slice(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableArray`1.Sort -M:System.Collections.Immutable.ImmutableArray`1.Sort(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Sort(System.Comparison{`0}) -M:System.Collections.Immutable.ImmutableArray`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableArray`1.ToBuilder -M:System.Collections.Immutable.ImmutableDictionary.Contains``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0,``1) -M:System.Collections.Immutable.ImmutableDictionary.Create``2 -M:System.Collections.Immutable.ImmutableDictionary.Create``2(System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableDictionary.Create``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2 -M:System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2(System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableDictionary.CreateBuilder``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableDictionary.CreateRange``2(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableDictionary.GetValueOrDefault``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0) -M:System.Collections.Immutable.ImmutableDictionary.GetValueOrDefault``2(System.Collections.Immutable.IImmutableDictionary{``0,``1},``0,``1) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}.Builder) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableDictionary.ToImmutableDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEqualityComparer{``2}) -M:System.Collections.Immutable.ImmutableDictionary`2.Add(`0,`1) -M:System.Collections.Immutable.ImmutableDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Add(`0,`1) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Add(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Clear -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.ContainsKey(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.ContainsValue(`1) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Count -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Item(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_KeyComparer -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Keys -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_ValueComparer -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.get_Values -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.GetEnumerator -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.GetValueOrDefault(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.GetValueOrDefault(`0,`1) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Remove(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.Remove(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.set_Item(`0,`1) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.set_KeyComparer(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.set_ValueComparer(System.Collections.Generic.IEqualityComparer{`1}) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.ToImmutable -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.TryGetKey(`0,`0@) -M:System.Collections.Immutable.ImmutableDictionary`2.Builder.TryGetValue(`0,`1@) -M:System.Collections.Immutable.ImmutableDictionary`2.Clear -M:System.Collections.Immutable.ImmutableDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableDictionary`2.ContainsKey(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.ContainsValue(`1) -M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.Dispose -M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableDictionary`2.Enumerator.Reset -M:System.Collections.Immutable.ImmutableDictionary`2.get_Count -M:System.Collections.Immutable.ImmutableDictionary`2.get_IsEmpty -M:System.Collections.Immutable.ImmutableDictionary`2.get_Item(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.get_KeyComparer -M:System.Collections.Immutable.ImmutableDictionary`2.get_Keys -M:System.Collections.Immutable.ImmutableDictionary`2.get_ValueComparer -M:System.Collections.Immutable.ImmutableDictionary`2.get_Values -M:System.Collections.Immutable.ImmutableDictionary`2.GetEnumerator -M:System.Collections.Immutable.ImmutableDictionary`2.Remove(`0) -M:System.Collections.Immutable.ImmutableDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableDictionary`2.SetItem(`0,`1) -M:System.Collections.Immutable.ImmutableDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.ImmutableDictionary`2.ToBuilder -M:System.Collections.Immutable.ImmutableDictionary`2.TryGetKey(`0,`0@) -M:System.Collections.Immutable.ImmutableDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Immutable.ImmutableDictionary`2.WithComparers(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableDictionary`2.WithComparers(System.Collections.Generic.IEqualityComparer{`0},System.Collections.Generic.IEqualityComparer{`1}) -M:System.Collections.Immutable.ImmutableHashSet.Create``1 -M:System.Collections.Immutable.ImmutableHashSet.Create``1(``0) -M:System.Collections.Immutable.ImmutableHashSet.Create``1(``0[]) -M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},``0) -M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},``0[]) -M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.Collections.Generic.IEqualityComparer{``0},System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableHashSet.Create``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableHashSet.CreateBuilder``1 -M:System.Collections.Immutable.ImmutableHashSet.CreateBuilder``1(System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableHashSet.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableHashSet.CreateRange``1(System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableHashSet.ToImmutableHashSet``1(System.Collections.Immutable.ImmutableHashSet{``0}.Builder) -M:System.Collections.Immutable.ImmutableHashSet`1.Add(`0) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Add(`0) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Clear -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Contains(`0) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.ExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.get_Count -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.get_KeyComparer -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.GetEnumerator -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IntersectWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.Remove(`0) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.set_KeyComparer(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.ToImmutable -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.TryGetValue(`0,`0@) -M:System.Collections.Immutable.ImmutableHashSet`1.Builder.UnionWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Clear -M:System.Collections.Immutable.ImmutableHashSet`1.Contains(`0) -M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.Dispose -M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableHashSet`1.Enumerator.Reset -M:System.Collections.Immutable.ImmutableHashSet`1.Except(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.get_Count -M:System.Collections.Immutable.ImmutableHashSet`1.get_IsEmpty -M:System.Collections.Immutable.ImmutableHashSet`1.get_KeyComparer -M:System.Collections.Immutable.ImmutableHashSet`1.GetEnumerator -M:System.Collections.Immutable.ImmutableHashSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.Remove(`0) -M:System.Collections.Immutable.ImmutableHashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.ToBuilder -M:System.Collections.Immutable.ImmutableHashSet`1.TryGetValue(`0,`0@) -M:System.Collections.Immutable.ImmutableHashSet`1.Union(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableHashSet`1.WithComparer(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableInterlocked.AddOrUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1,System.Func{``0,``1,``1}) -M:System.Collections.Immutable.ImmutableInterlocked.AddOrUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``1},System.Func{``0,``1,``1}) -M:System.Collections.Immutable.ImmutableInterlocked.Enqueue``1(System.Collections.Immutable.ImmutableQueue{``0}@,``0) -M:System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1) -M:System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``1}) -M:System.Collections.Immutable.ImmutableInterlocked.GetOrAdd``3(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,System.Func{``0,``2,``1},``2) -M:System.Collections.Immutable.ImmutableInterlocked.InterlockedCompareExchange``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0},System.Collections.Immutable.ImmutableArray{``0}) -M:System.Collections.Immutable.ImmutableInterlocked.InterlockedExchange``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0}) -M:System.Collections.Immutable.ImmutableInterlocked.InterlockedInitialize``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Collections.Immutable.ImmutableArray{``0}) -M:System.Collections.Immutable.ImmutableInterlocked.Push``1(System.Collections.Immutable.ImmutableStack{``0}@,``0) -M:System.Collections.Immutable.ImmutableInterlocked.TryAdd``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1) -M:System.Collections.Immutable.ImmutableInterlocked.TryDequeue``1(System.Collections.Immutable.ImmutableQueue{``0}@,``0@) -M:System.Collections.Immutable.ImmutableInterlocked.TryPop``1(System.Collections.Immutable.ImmutableStack{``0}@,``0@) -M:System.Collections.Immutable.ImmutableInterlocked.TryRemove``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1@) -M:System.Collections.Immutable.ImmutableInterlocked.TryUpdate``2(System.Collections.Immutable.ImmutableDictionary{``0,``1}@,``0,``1,``1) -M:System.Collections.Immutable.ImmutableInterlocked.Update``1(``0@,System.Func{``0,``0}) -M:System.Collections.Immutable.ImmutableInterlocked.Update``1(System.Collections.Immutable.ImmutableArray{``0}@,System.Func{System.Collections.Immutable.ImmutableArray{``0},System.Collections.Immutable.ImmutableArray{``0}}) -M:System.Collections.Immutable.ImmutableInterlocked.Update``2(``0@,System.Func{``0,``1,``0},``1) -M:System.Collections.Immutable.ImmutableInterlocked.Update``2(System.Collections.Immutable.ImmutableArray{``0}@,System.Func{System.Collections.Immutable.ImmutableArray{``0},``1,System.Collections.Immutable.ImmutableArray{``0}},``1) -M:System.Collections.Immutable.ImmutableList.Create``1 -M:System.Collections.Immutable.ImmutableList.Create``1(``0) -M:System.Collections.Immutable.ImmutableList.Create``1(``0[]) -M:System.Collections.Immutable.ImmutableList.Create``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableList.CreateBuilder``1 -M:System.Collections.Immutable.ImmutableList.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0) -M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32) -M:System.Collections.Immutable.ImmutableList.IndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0) -M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) -M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32) -M:System.Collections.Immutable.ImmutableList.LastIndexOf``1(System.Collections.Immutable.IImmutableList{``0},``0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList.Remove``1(System.Collections.Immutable.IImmutableList{``0},``0) -M:System.Collections.Immutable.ImmutableList.RemoveRange``1(System.Collections.Immutable.IImmutableList{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableList.Replace``1(System.Collections.Immutable.IImmutableList{``0},``0,``0) -M:System.Collections.Immutable.ImmutableList.ToImmutableList``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableList.ToImmutableList``1(System.Collections.Immutable.ImmutableList{``0}.Builder) -M:System.Collections.Immutable.ImmutableList`1.Add(`0) -M:System.Collections.Immutable.ImmutableList`1.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableList`1.BinarySearch(`0) -M:System.Collections.Immutable.ImmutableList`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Add(`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Clear -M:System.Collections.Immutable.ImmutableList`1.Builder.Contains(`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.ConvertAll``1(System.Func{`0,``0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(`0[]) -M:System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(`0[],System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.CopyTo(System.Int32,`0[],System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.Exists(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Find(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindIndex(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindLast(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.FindLastIndex(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.ForEach(System.Action{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.get_Count -M:System.Collections.Immutable.ImmutableList`1.Builder.get_Item(System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.GetEnumerator -M:System.Collections.Immutable.ImmutableList`1.Builder.GetRange(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Insert(System.Int32,`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.ItemRef(System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Remove(`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveAt(System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.RemoveRange(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.Replace(`0,`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Reverse -M:System.Collections.Immutable.ImmutableList`1.Builder.Reverse(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Builder.set_Item(System.Int32,`0) -M:System.Collections.Immutable.ImmutableList`1.Builder.Sort -M:System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Comparison{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Builder.ToImmutable -M:System.Collections.Immutable.ImmutableList`1.Builder.TrueForAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Clear -M:System.Collections.Immutable.ImmutableList`1.Contains(`0) -M:System.Collections.Immutable.ImmutableList`1.ConvertAll``1(System.Func{`0,``0}) -M:System.Collections.Immutable.ImmutableList`1.CopyTo(`0[]) -M:System.Collections.Immutable.ImmutableList`1.CopyTo(`0[],System.Int32) -M:System.Collections.Immutable.ImmutableList`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Enumerator.Dispose -M:System.Collections.Immutable.ImmutableList`1.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableList`1.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableList`1.Enumerator.Reset -M:System.Collections.Immutable.ImmutableList`1.Exists(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.Find(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindIndex(System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindIndex(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindLast(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Int32,System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.FindLastIndex(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.ForEach(System.Action{`0}) -M:System.Collections.Immutable.ImmutableList`1.get_Count -M:System.Collections.Immutable.ImmutableList`1.get_IsEmpty -M:System.Collections.Immutable.ImmutableList`1.get_Item(System.Int32) -M:System.Collections.Immutable.ImmutableList`1.GetEnumerator -M:System.Collections.Immutable.ImmutableList`1.GetRange(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.IndexOf(`0) -M:System.Collections.Immutable.ImmutableList`1.IndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Insert(System.Int32,`0) -M:System.Collections.Immutable.ImmutableList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableList`1.ItemRef(System.Int32) -M:System.Collections.Immutable.ImmutableList`1.LastIndexOf(`0,System.Int32,System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Remove(`0) -M:System.Collections.Immutable.ImmutableList`1.Remove(`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.RemoveAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableList`1.RemoveAt(System.Int32) -M:System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.RemoveRange(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.Replace(`0,`0) -M:System.Collections.Immutable.ImmutableList`1.Replace(`0,`0,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Reverse -M:System.Collections.Immutable.ImmutableList`1.Reverse(System.Int32,System.Int32) -M:System.Collections.Immutable.ImmutableList`1.SetItem(System.Int32,`0) -M:System.Collections.Immutable.ImmutableList`1.Sort -M:System.Collections.Immutable.ImmutableList`1.Sort(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.Sort(System.Comparison{`0}) -M:System.Collections.Immutable.ImmutableList`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableList`1.ToBuilder -M:System.Collections.Immutable.ImmutableList`1.TrueForAll(System.Predicate{`0}) -M:System.Collections.Immutable.ImmutableQueue.Create``1 -M:System.Collections.Immutable.ImmutableQueue.Create``1(``0) -M:System.Collections.Immutable.ImmutableQueue.Create``1(``0[]) -M:System.Collections.Immutable.ImmutableQueue.Create``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableQueue.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableQueue.Dequeue``1(System.Collections.Immutable.IImmutableQueue{``0},``0@) -M:System.Collections.Immutable.ImmutableQueue`1.Clear -M:System.Collections.Immutable.ImmutableQueue`1.Dequeue -M:System.Collections.Immutable.ImmutableQueue`1.Dequeue(`0@) -M:System.Collections.Immutable.ImmutableQueue`1.Enqueue(`0) -M:System.Collections.Immutable.ImmutableQueue`1.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableQueue`1.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableQueue`1.get_Empty -M:System.Collections.Immutable.ImmutableQueue`1.get_IsEmpty -M:System.Collections.Immutable.ImmutableQueue`1.GetEnumerator -M:System.Collections.Immutable.ImmutableQueue`1.Peek -M:System.Collections.Immutable.ImmutableQueue`1.PeekRef -M:System.Collections.Immutable.ImmutableSortedDictionary.Create``2 -M:System.Collections.Immutable.ImmutableSortedDictionary.Create``2(System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableSortedDictionary.Create``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2 -M:System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2(System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableSortedDictionary.CreateBuilder``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1},System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary.CreateRange``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``2(System.Collections.Immutable.ImmutableSortedDictionary{``0,``1}.Builder) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IComparer{``1}) -M:System.Collections.Immutable.ImmutableSortedDictionary.ToImmutableSortedDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IComparer{``1},System.Collections.Generic.IEqualityComparer{``2}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Add(`0,`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Add(`0,`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Add(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.AddRange(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Clear -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ContainsKey(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ContainsValue(`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Count -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Item(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_KeyComparer -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Keys -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_ValueComparer -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.get_Values -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetEnumerator -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetValueOrDefault(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.GetValueOrDefault(`0,`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Remove(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.Remove(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_Item(`0,`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_KeyComparer(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.set_ValueComparer(System.Collections.Generic.IEqualityComparer{`1}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ToImmutable -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.TryGetKey(`0,`0@) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.TryGetValue(`0,`1@) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder.ValueRef(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Clear -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.ContainsKey(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.ContainsValue(`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.Dispose -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator.Reset -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Count -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_IsEmpty -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Item(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_KeyComparer -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Keys -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_ValueComparer -M:System.Collections.Immutable.ImmutableSortedDictionary`2.get_Values -M:System.Collections.Immutable.ImmutableSortedDictionary`2.GetEnumerator -M:System.Collections.Immutable.ImmutableSortedDictionary`2.Remove(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.RemoveRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.SetItem(`0,`1) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.SetItems(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.ToBuilder -M:System.Collections.Immutable.ImmutableSortedDictionary`2.TryGetKey(`0,`0@) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.ValueRef(`0) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.WithComparers(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableSortedDictionary`2.WithComparers(System.Collections.Generic.IComparer{`0},System.Collections.Generic.IEqualityComparer{`1}) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1 -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(``0) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(``0[]) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},``0) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},``0[]) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.Collections.Generic.IComparer{``0},System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.Create``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.CreateBuilder``1 -M:System.Collections.Immutable.ImmutableSortedSet.CreateBuilder``1(System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.CreateRange``1(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) -M:System.Collections.Immutable.ImmutableSortedSet.ToImmutableSortedSet``1(System.Collections.Immutable.ImmutableSortedSet{``0}.Builder) -M:System.Collections.Immutable.ImmutableSortedSet`1.Add(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Add(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Clear -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Contains(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.ExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Count -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Item(System.Int32) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_KeyComparer -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Max -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.get_Min -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.GetEnumerator -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IndexOf(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IntersectWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.ItemRef(System.Int32) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Remove(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.Reverse -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.set_KeyComparer(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.ToImmutable -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.TryGetValue(`0,`0@) -M:System.Collections.Immutable.ImmutableSortedSet`1.Builder.UnionWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Clear -M:System.Collections.Immutable.ImmutableSortedSet`1.Contains(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.Dispose -M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator.Reset -M:System.Collections.Immutable.ImmutableSortedSet`1.Except(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.get_Count -M:System.Collections.Immutable.ImmutableSortedSet`1.get_IsEmpty -M:System.Collections.Immutable.ImmutableSortedSet`1.get_Item(System.Int32) -M:System.Collections.Immutable.ImmutableSortedSet`1.get_KeyComparer -M:System.Collections.Immutable.ImmutableSortedSet`1.get_Max -M:System.Collections.Immutable.ImmutableSortedSet`1.get_Min -M:System.Collections.Immutable.ImmutableSortedSet`1.GetEnumerator -M:System.Collections.Immutable.ImmutableSortedSet`1.IndexOf(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Intersect(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.ItemRef(System.Int32) -M:System.Collections.Immutable.ImmutableSortedSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.Remove(`0) -M:System.Collections.Immutable.ImmutableSortedSet`1.Reverse -M:System.Collections.Immutable.ImmutableSortedSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.SymmetricExcept(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.ToBuilder -M:System.Collections.Immutable.ImmutableSortedSet`1.TryGetValue(`0,`0@) -M:System.Collections.Immutable.ImmutableSortedSet`1.Union(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Immutable.ImmutableSortedSet`1.WithComparer(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Immutable.ImmutableStack.Create``1 -M:System.Collections.Immutable.ImmutableStack.Create``1(``0) -M:System.Collections.Immutable.ImmutableStack.Create``1(``0[]) -M:System.Collections.Immutable.ImmutableStack.Create``1(System.ReadOnlySpan{``0}) -M:System.Collections.Immutable.ImmutableStack.CreateRange``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Collections.Immutable.ImmutableStack.Pop``1(System.Collections.Immutable.IImmutableStack{``0},``0@) -M:System.Collections.Immutable.ImmutableStack`1.Clear -M:System.Collections.Immutable.ImmutableStack`1.Enumerator.get_Current -M:System.Collections.Immutable.ImmutableStack`1.Enumerator.MoveNext -M:System.Collections.Immutable.ImmutableStack`1.get_Empty -M:System.Collections.Immutable.ImmutableStack`1.get_IsEmpty -M:System.Collections.Immutable.ImmutableStack`1.GetEnumerator -M:System.Collections.Immutable.ImmutableStack`1.Peek -M:System.Collections.Immutable.ImmutableStack`1.PeekRef -M:System.Collections.Immutable.ImmutableStack`1.Pop -M:System.Collections.Immutable.ImmutableStack`1.Pop(`0@) -M:System.Collections.Immutable.ImmutableStack`1.Push(`0) -M:System.Linq.ImmutableArrayExtensions.Aggregate``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``0,``0}) -M:System.Linq.ImmutableArrayExtensions.Aggregate``2(System.Collections.Immutable.ImmutableArray{``1},``0,System.Func{``0,``1,``0}) -M:System.Linq.ImmutableArrayExtensions.Aggregate``3(System.Collections.Immutable.ImmutableArray{``2},``0,System.Func{``0,``2,``0},System.Func{``0,``1}) -M:System.Linq.ImmutableArrayExtensions.All``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.Any``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Linq.ImmutableArrayExtensions.ElementAt``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32) -M:System.Linq.ImmutableArrayExtensions.ElementAtOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Int32) -M:System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.First``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.FirstOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.Last``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.LastOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}.Builder) -M:System.Linq.ImmutableArrayExtensions.Select``2(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,``1}) -M:System.Linq.ImmutableArrayExtensions.SelectMany``3(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) -M:System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Immutable.ImmutableArray{``0},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.ImmutableArrayExtensions.SequenceEqual``2(System.Collections.Immutable.ImmutableArray{``1},System.Collections.Immutable.ImmutableArray{``0},System.Func{``1,``1,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.Single``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.Single``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.SingleOrDefault``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.SingleOrDefault``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Linq.ImmutableArrayExtensions.ToArray``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Linq.ImmutableArrayExtensions.ToDictionary``2(System.Collections.Immutable.ImmutableArray{``1},System.Func{``1,``0}) -M:System.Linq.ImmutableArrayExtensions.ToDictionary``2(System.Collections.Immutable.ImmutableArray{``1},System.Func{``1,``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.ImmutableArrayExtensions.ToDictionary``3(System.Collections.Immutable.ImmutableArray{``2},System.Func{``2,``0},System.Func{``2,``1}) -M:System.Linq.ImmutableArrayExtensions.ToDictionary``3(System.Collections.Immutable.ImmutableArray{``2},System.Func{``2,``0},System.Func{``2,``1},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.ImmutableArrayExtensions.Where``1(System.Collections.Immutable.ImmutableArray{``0},System.Func{``0,System.Boolean}) -M:System.Runtime.InteropServices.ImmutableCollectionsMarshal.AsArray``1(System.Collections.Immutable.ImmutableArray{``0}) -M:System.Runtime.InteropServices.ImmutableCollectionsMarshal.AsImmutableArray``1(``0[]) -T:System.Collections.Frozen.FrozenDictionary -T:System.Collections.Frozen.FrozenDictionary`2 -T:System.Collections.Frozen.FrozenDictionary`2.Enumerator -T:System.Collections.Frozen.FrozenSet -T:System.Collections.Frozen.FrozenSet`1 -T:System.Collections.Frozen.FrozenSet`1.Enumerator -T:System.Collections.Immutable.IImmutableDictionary`2 -T:System.Collections.Immutable.IImmutableList`1 -T:System.Collections.Immutable.IImmutableQueue`1 -T:System.Collections.Immutable.IImmutableSet`1 -T:System.Collections.Immutable.IImmutableStack`1 -T:System.Collections.Immutable.ImmutableArray -T:System.Collections.Immutable.ImmutableArray`1 -T:System.Collections.Immutable.ImmutableArray`1.Builder -T:System.Collections.Immutable.ImmutableArray`1.Enumerator -T:System.Collections.Immutable.ImmutableDictionary -T:System.Collections.Immutable.ImmutableDictionary`2 -T:System.Collections.Immutable.ImmutableDictionary`2.Builder -T:System.Collections.Immutable.ImmutableDictionary`2.Enumerator -T:System.Collections.Immutable.ImmutableHashSet -T:System.Collections.Immutable.ImmutableHashSet`1 -T:System.Collections.Immutable.ImmutableHashSet`1.Builder -T:System.Collections.Immutable.ImmutableHashSet`1.Enumerator -T:System.Collections.Immutable.ImmutableInterlocked -T:System.Collections.Immutable.ImmutableList -T:System.Collections.Immutable.ImmutableList`1 -T:System.Collections.Immutable.ImmutableList`1.Builder -T:System.Collections.Immutable.ImmutableList`1.Enumerator -T:System.Collections.Immutable.ImmutableQueue -T:System.Collections.Immutable.ImmutableQueue`1 -T:System.Collections.Immutable.ImmutableQueue`1.Enumerator -T:System.Collections.Immutable.ImmutableSortedDictionary -T:System.Collections.Immutable.ImmutableSortedDictionary`2 -T:System.Collections.Immutable.ImmutableSortedDictionary`2.Builder -T:System.Collections.Immutable.ImmutableSortedDictionary`2.Enumerator -T:System.Collections.Immutable.ImmutableSortedSet -T:System.Collections.Immutable.ImmutableSortedSet`1 -T:System.Collections.Immutable.ImmutableSortedSet`1.Builder -T:System.Collections.Immutable.ImmutableSortedSet`1.Enumerator -T:System.Collections.Immutable.ImmutableStack -T:System.Collections.Immutable.ImmutableStack`1 -T:System.Collections.Immutable.ImmutableStack`1.Enumerator -T:System.Linq.ImmutableArrayExtensions -T:System.Runtime.InteropServices.ImmutableCollectionsMarshal \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt deleted file mode 100644 index 6476ecccd5041..0000000000000 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Collections.txt +++ /dev/null @@ -1,431 +0,0 @@ -M:System.Collections.BitArray.#ctor(System.Boolean[]) -M:System.Collections.BitArray.#ctor(System.Byte[]) -M:System.Collections.BitArray.#ctor(System.Collections.BitArray) -M:System.Collections.BitArray.#ctor(System.Int32) -M:System.Collections.BitArray.#ctor(System.Int32,System.Boolean) -M:System.Collections.BitArray.#ctor(System.Int32[]) -M:System.Collections.BitArray.And(System.Collections.BitArray) -M:System.Collections.BitArray.Clone -M:System.Collections.BitArray.CopyTo(System.Array,System.Int32) -M:System.Collections.BitArray.Get(System.Int32) -M:System.Collections.BitArray.get_Count -M:System.Collections.BitArray.get_IsReadOnly -M:System.Collections.BitArray.get_IsSynchronized -M:System.Collections.BitArray.get_Item(System.Int32) -M:System.Collections.BitArray.get_Length -M:System.Collections.BitArray.get_SyncRoot -M:System.Collections.BitArray.GetEnumerator -M:System.Collections.BitArray.HasAllSet -M:System.Collections.BitArray.HasAnySet -M:System.Collections.BitArray.LeftShift(System.Int32) -M:System.Collections.BitArray.Not -M:System.Collections.BitArray.Or(System.Collections.BitArray) -M:System.Collections.BitArray.RightShift(System.Int32) -M:System.Collections.BitArray.Set(System.Int32,System.Boolean) -M:System.Collections.BitArray.set_Item(System.Int32,System.Boolean) -M:System.Collections.BitArray.set_Length(System.Int32) -M:System.Collections.BitArray.SetAll(System.Boolean) -M:System.Collections.BitArray.Xor(System.Collections.BitArray) -M:System.Collections.Generic.CollectionExtensions.AddRange``1(System.Collections.Generic.List{``0},System.ReadOnlySpan{``0}) -M:System.Collections.Generic.CollectionExtensions.AsReadOnly``1(System.Collections.Generic.IList{``0}) -M:System.Collections.Generic.CollectionExtensions.AsReadOnly``2(System.Collections.Generic.IDictionary{``0,``1}) -M:System.Collections.Generic.CollectionExtensions.CopyTo``1(System.Collections.Generic.List{``0},System.Span{``0}) -M:System.Collections.Generic.CollectionExtensions.GetValueOrDefault``2(System.Collections.Generic.IReadOnlyDictionary{``0,``1},``0) -M:System.Collections.Generic.CollectionExtensions.GetValueOrDefault``2(System.Collections.Generic.IReadOnlyDictionary{``0,``1},``0,``1) -M:System.Collections.Generic.CollectionExtensions.InsertRange``1(System.Collections.Generic.List{``0},System.Int32,System.ReadOnlySpan{``0}) -M:System.Collections.Generic.CollectionExtensions.Remove``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1@) -M:System.Collections.Generic.CollectionExtensions.TryAdd``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1) -M:System.Collections.Generic.Comparer`1.#ctor -M:System.Collections.Generic.Comparer`1.Compare(`0,`0) -M:System.Collections.Generic.Comparer`1.Create(System.Comparison{`0}) -M:System.Collections.Generic.Comparer`1.get_Default -M:System.Collections.Generic.Dictionary`2.#ctor -M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}}) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Int32) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.Dictionary`2.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.Dictionary`2.Add(`0,`1) -M:System.Collections.Generic.Dictionary`2.Clear -M:System.Collections.Generic.Dictionary`2.ContainsKey(`0) -M:System.Collections.Generic.Dictionary`2.ContainsValue(`1) -M:System.Collections.Generic.Dictionary`2.EnsureCapacity(System.Int32) -M:System.Collections.Generic.Dictionary`2.Enumerator.Dispose -M:System.Collections.Generic.Dictionary`2.Enumerator.get_Current -M:System.Collections.Generic.Dictionary`2.Enumerator.MoveNext -M:System.Collections.Generic.Dictionary`2.get_Comparer -M:System.Collections.Generic.Dictionary`2.get_Count -M:System.Collections.Generic.Dictionary`2.get_Item(`0) -M:System.Collections.Generic.Dictionary`2.get_Keys -M:System.Collections.Generic.Dictionary`2.get_Values -M:System.Collections.Generic.Dictionary`2.GetEnumerator -M:System.Collections.Generic.Dictionary`2.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.Dictionary`2.KeyCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) -M:System.Collections.Generic.Dictionary`2.KeyCollection.Contains(`0) -M:System.Collections.Generic.Dictionary`2.KeyCollection.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.Dispose -M:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.get_Current -M:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator.MoveNext -M:System.Collections.Generic.Dictionary`2.KeyCollection.get_Count -M:System.Collections.Generic.Dictionary`2.KeyCollection.GetEnumerator -M:System.Collections.Generic.Dictionary`2.OnDeserialization(System.Object) -M:System.Collections.Generic.Dictionary`2.Remove(`0) -M:System.Collections.Generic.Dictionary`2.Remove(`0,`1@) -M:System.Collections.Generic.Dictionary`2.set_Item(`0,`1) -M:System.Collections.Generic.Dictionary`2.TrimExcess -M:System.Collections.Generic.Dictionary`2.TrimExcess(System.Int32) -M:System.Collections.Generic.Dictionary`2.TryAdd(`0,`1) -M:System.Collections.Generic.Dictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Generic.Dictionary`2.ValueCollection.#ctor(System.Collections.Generic.Dictionary{`0,`1}) -M:System.Collections.Generic.Dictionary`2.ValueCollection.CopyTo(`1[],System.Int32) -M:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.Dispose -M:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.get_Current -M:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator.MoveNext -M:System.Collections.Generic.Dictionary`2.ValueCollection.get_Count -M:System.Collections.Generic.Dictionary`2.ValueCollection.GetEnumerator -M:System.Collections.Generic.EqualityComparer`1.#ctor -M:System.Collections.Generic.EqualityComparer`1.Create(System.Func{`0,`0,System.Boolean},System.Func{`0,System.Int32}) -M:System.Collections.Generic.EqualityComparer`1.Equals(`0,`0) -M:System.Collections.Generic.EqualityComparer`1.get_Default -M:System.Collections.Generic.EqualityComparer`1.GetHashCode(`0) -M:System.Collections.Generic.HashSet`1.#ctor -M:System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.HashSet`1.#ctor(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.HashSet`1.#ctor(System.Int32) -M:System.Collections.Generic.HashSet`1.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.HashSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.HashSet`1.Add(`0) -M:System.Collections.Generic.HashSet`1.Clear -M:System.Collections.Generic.HashSet`1.Contains(`0) -M:System.Collections.Generic.HashSet`1.CopyTo(`0[]) -M:System.Collections.Generic.HashSet`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.HashSet`1.CopyTo(`0[],System.Int32,System.Int32) -M:System.Collections.Generic.HashSet`1.CreateSetComparer -M:System.Collections.Generic.HashSet`1.EnsureCapacity(System.Int32) -M:System.Collections.Generic.HashSet`1.Enumerator.Dispose -M:System.Collections.Generic.HashSet`1.Enumerator.get_Current -M:System.Collections.Generic.HashSet`1.Enumerator.MoveNext -M:System.Collections.Generic.HashSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.get_Comparer -M:System.Collections.Generic.HashSet`1.get_Count -M:System.Collections.Generic.HashSet`1.GetEnumerator -M:System.Collections.Generic.HashSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.HashSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.OnDeserialization(System.Object) -M:System.Collections.Generic.HashSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.Remove(`0) -M:System.Collections.Generic.HashSet`1.RemoveWhere(System.Predicate{`0}) -M:System.Collections.Generic.HashSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.HashSet`1.TrimExcess -M:System.Collections.Generic.HashSet`1.TryGetValue(`0,`0@) -M:System.Collections.Generic.HashSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.LinkedList`1.#ctor -M:System.Collections.Generic.LinkedList`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.LinkedList`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.LinkedList`1.AddAfter(System.Collections.Generic.LinkedListNode{`0},`0) -M:System.Collections.Generic.LinkedList`1.AddAfter(System.Collections.Generic.LinkedListNode{`0},System.Collections.Generic.LinkedListNode{`0}) -M:System.Collections.Generic.LinkedList`1.AddBefore(System.Collections.Generic.LinkedListNode{`0},`0) -M:System.Collections.Generic.LinkedList`1.AddBefore(System.Collections.Generic.LinkedListNode{`0},System.Collections.Generic.LinkedListNode{`0}) -M:System.Collections.Generic.LinkedList`1.AddFirst(`0) -M:System.Collections.Generic.LinkedList`1.AddFirst(System.Collections.Generic.LinkedListNode{`0}) -M:System.Collections.Generic.LinkedList`1.AddLast(`0) -M:System.Collections.Generic.LinkedList`1.AddLast(System.Collections.Generic.LinkedListNode{`0}) -M:System.Collections.Generic.LinkedList`1.Clear -M:System.Collections.Generic.LinkedList`1.Contains(`0) -M:System.Collections.Generic.LinkedList`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.LinkedList`1.Enumerator.Dispose -M:System.Collections.Generic.LinkedList`1.Enumerator.get_Current -M:System.Collections.Generic.LinkedList`1.Enumerator.MoveNext -M:System.Collections.Generic.LinkedList`1.Find(`0) -M:System.Collections.Generic.LinkedList`1.FindLast(`0) -M:System.Collections.Generic.LinkedList`1.get_Count -M:System.Collections.Generic.LinkedList`1.get_First -M:System.Collections.Generic.LinkedList`1.get_Last -M:System.Collections.Generic.LinkedList`1.GetEnumerator -M:System.Collections.Generic.LinkedList`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.LinkedList`1.OnDeserialization(System.Object) -M:System.Collections.Generic.LinkedList`1.Remove(`0) -M:System.Collections.Generic.LinkedList`1.Remove(System.Collections.Generic.LinkedListNode{`0}) -M:System.Collections.Generic.LinkedList`1.RemoveFirst -M:System.Collections.Generic.LinkedList`1.RemoveLast -M:System.Collections.Generic.LinkedListNode`1.#ctor(`0) -M:System.Collections.Generic.LinkedListNode`1.get_List -M:System.Collections.Generic.LinkedListNode`1.get_Next -M:System.Collections.Generic.LinkedListNode`1.get_Previous -M:System.Collections.Generic.LinkedListNode`1.get_Value -M:System.Collections.Generic.LinkedListNode`1.get_ValueRef -M:System.Collections.Generic.LinkedListNode`1.set_Value(`0) -M:System.Collections.Generic.List`1.#ctor -M:System.Collections.Generic.List`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.List`1.#ctor(System.Int32) -M:System.Collections.Generic.List`1.Add(`0) -M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.List`1.AsReadOnly -M:System.Collections.Generic.List`1.BinarySearch(`0) -M:System.Collections.Generic.List`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.List`1.BinarySearch(System.Int32,System.Int32,`0,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.List`1.Clear -M:System.Collections.Generic.List`1.Contains(`0) -M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0}) -M:System.Collections.Generic.List`1.CopyTo(`0[]) -M:System.Collections.Generic.List`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.List`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32) -M:System.Collections.Generic.List`1.EnsureCapacity(System.Int32) -M:System.Collections.Generic.List`1.Enumerator.Dispose -M:System.Collections.Generic.List`1.Enumerator.get_Current -M:System.Collections.Generic.List`1.Enumerator.MoveNext -M:System.Collections.Generic.List`1.Exists(System.Predicate{`0}) -M:System.Collections.Generic.List`1.Find(System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindAll(System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindIndex(System.Int32,System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindIndex(System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindLast(System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindLastIndex(System.Int32,System.Predicate{`0}) -M:System.Collections.Generic.List`1.FindLastIndex(System.Predicate{`0}) -M:System.Collections.Generic.List`1.ForEach(System.Action{`0}) -M:System.Collections.Generic.List`1.get_Capacity -M:System.Collections.Generic.List`1.get_Count -M:System.Collections.Generic.List`1.get_Item(System.Int32) -M:System.Collections.Generic.List`1.GetEnumerator -M:System.Collections.Generic.List`1.GetRange(System.Int32,System.Int32) -M:System.Collections.Generic.List`1.IndexOf(`0) -M:System.Collections.Generic.List`1.IndexOf(`0,System.Int32) -M:System.Collections.Generic.List`1.IndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Generic.List`1.Insert(System.Int32,`0) -M:System.Collections.Generic.List`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.List`1.LastIndexOf(`0) -M:System.Collections.Generic.List`1.LastIndexOf(`0,System.Int32) -M:System.Collections.Generic.List`1.LastIndexOf(`0,System.Int32,System.Int32) -M:System.Collections.Generic.List`1.Remove(`0) -M:System.Collections.Generic.List`1.RemoveAll(System.Predicate{`0}) -M:System.Collections.Generic.List`1.RemoveAt(System.Int32) -M:System.Collections.Generic.List`1.RemoveRange(System.Int32,System.Int32) -M:System.Collections.Generic.List`1.Reverse -M:System.Collections.Generic.List`1.Reverse(System.Int32,System.Int32) -M:System.Collections.Generic.List`1.set_Capacity(System.Int32) -M:System.Collections.Generic.List`1.set_Item(System.Int32,`0) -M:System.Collections.Generic.List`1.Slice(System.Int32,System.Int32) -M:System.Collections.Generic.List`1.Sort -M:System.Collections.Generic.List`1.Sort(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.List`1.Sort(System.Comparison{`0}) -M:System.Collections.Generic.List`1.Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.List`1.ToArray -M:System.Collections.Generic.List`1.TrimExcess -M:System.Collections.Generic.List`1.TrueForAll(System.Predicate{`0}) -M:System.Collections.Generic.PriorityQueue`2.#ctor -M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IComparer{`1}) -M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}}) -M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}},System.Collections.Generic.IComparer{`1}) -M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Int32) -M:System.Collections.Generic.PriorityQueue`2.#ctor(System.Int32,System.Collections.Generic.IComparer{`1}) -M:System.Collections.Generic.PriorityQueue`2.Clear -M:System.Collections.Generic.PriorityQueue`2.Dequeue -M:System.Collections.Generic.PriorityQueue`2.DequeueEnqueue(`0,`1) -M:System.Collections.Generic.PriorityQueue`2.Enqueue(`0,`1) -M:System.Collections.Generic.PriorityQueue`2.EnqueueDequeue(`0,`1) -M:System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{`0},`1) -M:System.Collections.Generic.PriorityQueue`2.EnqueueRange(System.Collections.Generic.IEnumerable{System.ValueTuple{`0,`1}}) -M:System.Collections.Generic.PriorityQueue`2.EnsureCapacity(System.Int32) -M:System.Collections.Generic.PriorityQueue`2.get_Comparer -M:System.Collections.Generic.PriorityQueue`2.get_Count -M:System.Collections.Generic.PriorityQueue`2.get_UnorderedItems -M:System.Collections.Generic.PriorityQueue`2.Peek -M:System.Collections.Generic.PriorityQueue`2.TrimExcess -M:System.Collections.Generic.PriorityQueue`2.TryDequeue(`0@,`1@) -M:System.Collections.Generic.PriorityQueue`2.TryPeek(`0@,`1@) -M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.Dispose -M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.get_Current -M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator.MoveNext -M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.get_Count -M:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.GetEnumerator -M:System.Collections.Generic.Queue`1.#ctor -M:System.Collections.Generic.Queue`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.Queue`1.#ctor(System.Int32) -M:System.Collections.Generic.Queue`1.Clear -M:System.Collections.Generic.Queue`1.Contains(`0) -M:System.Collections.Generic.Queue`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.Queue`1.Dequeue -M:System.Collections.Generic.Queue`1.Enqueue(`0) -M:System.Collections.Generic.Queue`1.EnsureCapacity(System.Int32) -M:System.Collections.Generic.Queue`1.Enumerator.Dispose -M:System.Collections.Generic.Queue`1.Enumerator.get_Current -M:System.Collections.Generic.Queue`1.Enumerator.MoveNext -M:System.Collections.Generic.Queue`1.get_Count -M:System.Collections.Generic.Queue`1.GetEnumerator -M:System.Collections.Generic.Queue`1.Peek -M:System.Collections.Generic.Queue`1.ToArray -M:System.Collections.Generic.Queue`1.TrimExcess -M:System.Collections.Generic.Queue`1.TryDequeue(`0@) -M:System.Collections.Generic.Queue`1.TryPeek(`0@) -M:System.Collections.Generic.ReferenceEqualityComparer.Equals(System.Object,System.Object) -M:System.Collections.Generic.ReferenceEqualityComparer.get_Instance -M:System.Collections.Generic.ReferenceEqualityComparer.GetHashCode(System.Object) -M:System.Collections.Generic.SortedDictionary`2.#ctor -M:System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) -M:System.Collections.Generic.SortedDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedDictionary`2.Add(`0,`1) -M:System.Collections.Generic.SortedDictionary`2.Clear -M:System.Collections.Generic.SortedDictionary`2.ContainsKey(`0) -M:System.Collections.Generic.SortedDictionary`2.ContainsValue(`1) -M:System.Collections.Generic.SortedDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32) -M:System.Collections.Generic.SortedDictionary`2.Enumerator.Dispose -M:System.Collections.Generic.SortedDictionary`2.Enumerator.get_Current -M:System.Collections.Generic.SortedDictionary`2.Enumerator.MoveNext -M:System.Collections.Generic.SortedDictionary`2.get_Comparer -M:System.Collections.Generic.SortedDictionary`2.get_Count -M:System.Collections.Generic.SortedDictionary`2.get_Item(`0) -M:System.Collections.Generic.SortedDictionary`2.get_Keys -M:System.Collections.Generic.SortedDictionary`2.get_Values -M:System.Collections.Generic.SortedDictionary`2.GetEnumerator -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.#ctor(System.Collections.Generic.SortedDictionary{`0,`1}) -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Contains(`0) -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.Dispose -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.get_Current -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator.MoveNext -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.get_Count -M:System.Collections.Generic.SortedDictionary`2.KeyCollection.GetEnumerator -M:System.Collections.Generic.SortedDictionary`2.Remove(`0) -M:System.Collections.Generic.SortedDictionary`2.set_Item(`0,`1) -M:System.Collections.Generic.SortedDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.#ctor(System.Collections.Generic.SortedDictionary{`0,`1}) -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.Dispose -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.get_Current -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator.MoveNext -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.get_Count -M:System.Collections.Generic.SortedDictionary`2.ValueCollection.GetEnumerator -M:System.Collections.Generic.SortedList`2.#ctor -M:System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) -M:System.Collections.Generic.SortedList`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedList`2.#ctor(System.Int32) -M:System.Collections.Generic.SortedList`2.#ctor(System.Int32,System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedList`2.Add(`0,`1) -M:System.Collections.Generic.SortedList`2.Clear -M:System.Collections.Generic.SortedList`2.ContainsKey(`0) -M:System.Collections.Generic.SortedList`2.ContainsValue(`1) -M:System.Collections.Generic.SortedList`2.get_Capacity -M:System.Collections.Generic.SortedList`2.get_Comparer -M:System.Collections.Generic.SortedList`2.get_Count -M:System.Collections.Generic.SortedList`2.get_Item(`0) -M:System.Collections.Generic.SortedList`2.get_Keys -M:System.Collections.Generic.SortedList`2.get_Values -M:System.Collections.Generic.SortedList`2.GetEnumerator -M:System.Collections.Generic.SortedList`2.GetKeyAtIndex(System.Int32) -M:System.Collections.Generic.SortedList`2.GetValueAtIndex(System.Int32) -M:System.Collections.Generic.SortedList`2.IndexOfKey(`0) -M:System.Collections.Generic.SortedList`2.IndexOfValue(`1) -M:System.Collections.Generic.SortedList`2.Remove(`0) -M:System.Collections.Generic.SortedList`2.RemoveAt(System.Int32) -M:System.Collections.Generic.SortedList`2.set_Capacity(System.Int32) -M:System.Collections.Generic.SortedList`2.set_Item(`0,`1) -M:System.Collections.Generic.SortedList`2.SetValueAtIndex(System.Int32,`1) -M:System.Collections.Generic.SortedList`2.TrimExcess -M:System.Collections.Generic.SortedList`2.TryGetValue(`0,`1@) -M:System.Collections.Generic.SortedSet`1.#ctor -M:System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IComparer{`0}) -M:System.Collections.Generic.SortedSet`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.SortedSet`1.Add(`0) -M:System.Collections.Generic.SortedSet`1.Clear -M:System.Collections.Generic.SortedSet`1.Contains(`0) -M:System.Collections.Generic.SortedSet`1.CopyTo(`0[]) -M:System.Collections.Generic.SortedSet`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.SortedSet`1.CopyTo(`0[],System.Int32,System.Int32) -M:System.Collections.Generic.SortedSet`1.CreateSetComparer -M:System.Collections.Generic.SortedSet`1.CreateSetComparer(System.Collections.Generic.IEqualityComparer{`0}) -M:System.Collections.Generic.SortedSet`1.Enumerator.Dispose -M:System.Collections.Generic.SortedSet`1.Enumerator.get_Current -M:System.Collections.Generic.SortedSet`1.Enumerator.MoveNext -M:System.Collections.Generic.SortedSet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.get_Comparer -M:System.Collections.Generic.SortedSet`1.get_Count -M:System.Collections.Generic.SortedSet`1.get_Max -M:System.Collections.Generic.SortedSet`1.get_Min -M:System.Collections.Generic.SortedSet`1.GetEnumerator -M:System.Collections.Generic.SortedSet`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.SortedSet`1.GetViewBetween(`0,`0) -M:System.Collections.Generic.SortedSet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.OnDeserialization(System.Object) -M:System.Collections.Generic.SortedSet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.Remove(`0) -M:System.Collections.Generic.SortedSet`1.RemoveWhere(System.Predicate{`0}) -M:System.Collections.Generic.SortedSet`1.Reverse -M:System.Collections.Generic.SortedSet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.SortedSet`1.TryGetValue(`0,`0@) -M:System.Collections.Generic.SortedSet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.Stack`1.#ctor -M:System.Collections.Generic.Stack`1.#ctor(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.Stack`1.#ctor(System.Int32) -M:System.Collections.Generic.Stack`1.Clear -M:System.Collections.Generic.Stack`1.Contains(`0) -M:System.Collections.Generic.Stack`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.Stack`1.EnsureCapacity(System.Int32) -M:System.Collections.Generic.Stack`1.Enumerator.Dispose -M:System.Collections.Generic.Stack`1.Enumerator.get_Current -M:System.Collections.Generic.Stack`1.Enumerator.MoveNext -M:System.Collections.Generic.Stack`1.get_Count -M:System.Collections.Generic.Stack`1.GetEnumerator -M:System.Collections.Generic.Stack`1.Peek -M:System.Collections.Generic.Stack`1.Pop -M:System.Collections.Generic.Stack`1.Push(`0) -M:System.Collections.Generic.Stack`1.ToArray -M:System.Collections.Generic.Stack`1.TrimExcess -M:System.Collections.Generic.Stack`1.TryPeek(`0@) -M:System.Collections.Generic.Stack`1.TryPop(`0@) -M:System.Collections.StructuralComparisons.get_StructuralComparer -M:System.Collections.StructuralComparisons.get_StructuralEqualityComparer -T:System.Collections.BitArray -T:System.Collections.Generic.CollectionExtensions -T:System.Collections.Generic.Comparer`1 -T:System.Collections.Generic.Dictionary`2 -T:System.Collections.Generic.Dictionary`2.Enumerator -T:System.Collections.Generic.Dictionary`2.KeyCollection -T:System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator -T:System.Collections.Generic.Dictionary`2.ValueCollection -T:System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator -T:System.Collections.Generic.EqualityComparer`1 -T:System.Collections.Generic.HashSet`1 -T:System.Collections.Generic.HashSet`1.Enumerator -T:System.Collections.Generic.LinkedList`1 -T:System.Collections.Generic.LinkedList`1.Enumerator -T:System.Collections.Generic.LinkedListNode`1 -T:System.Collections.Generic.List`1 -T:System.Collections.Generic.List`1.Enumerator -T:System.Collections.Generic.PriorityQueue`2 -T:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection -T:System.Collections.Generic.PriorityQueue`2.UnorderedItemsCollection.Enumerator -T:System.Collections.Generic.Queue`1 -T:System.Collections.Generic.Queue`1.Enumerator -T:System.Collections.Generic.ReferenceEqualityComparer -T:System.Collections.Generic.SortedDictionary`2 -T:System.Collections.Generic.SortedDictionary`2.Enumerator -T:System.Collections.Generic.SortedDictionary`2.KeyCollection -T:System.Collections.Generic.SortedDictionary`2.KeyCollection.Enumerator -T:System.Collections.Generic.SortedDictionary`2.ValueCollection -T:System.Collections.Generic.SortedDictionary`2.ValueCollection.Enumerator -T:System.Collections.Generic.SortedList`2 -T:System.Collections.Generic.SortedSet`1 -T:System.Collections.Generic.SortedSet`1.Enumerator -T:System.Collections.Generic.Stack`1 -T:System.Collections.Generic.Stack`1.Enumerator -T:System.Collections.StructuralComparisons \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt deleted file mode 100644 index a9dec4ae8affc..0000000000000 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Linq.txt +++ /dev/null @@ -1,231 +0,0 @@ -M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0}) -M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1}) -M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2}) -M:System.Linq.Enumerable.All``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.AsEnumerable``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Decimal}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Double}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Int32}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Int64}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Average(System.Collections.Generic.IEnumerable{System.Single}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Average``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) -M:System.Linq.Enumerable.Cast``1(System.Collections.IEnumerable) -M:System.Linq.Enumerable.Chunk``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.Distinct``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Distinct``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.ElementAt``1(System.Collections.Generic.IEnumerable{``0},System.Index) -M:System.Linq.Enumerable.ElementAt``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.ElementAtOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Index) -M:System.Linq.Enumerable.ElementAtOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.Empty``1 -M:System.Linq.Enumerable.Except``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Except``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) -M:System.Linq.Enumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.First``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.First``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.FirstOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) -M:System.Linq.Enumerable.GroupBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.GroupBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) -M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2}) -M:System.Linq.Enumerable.GroupBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3}) -M:System.Linq.Enumerable.GroupBy``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,System.Collections.Generic.IEnumerable{``2},``3},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3}) -M:System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2}) -M:System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Intersect``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1}) -M:System.Linq.Enumerable.IntersectBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3}) -M:System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2}) -M:System.Linq.Enumerable.Last``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Last``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.LastOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) -M:System.Linq.Enumerable.LongCount``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.LongCount``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Decimal}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Double}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Int32}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Int64}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Max(System.Collections.Generic.IEnumerable{System.Single}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Max``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) -M:System.Linq.Enumerable.Max``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Decimal}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Double}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Int32}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Int64}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Min(System.Collections.Generic.IEnumerable{System.Single}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Min``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) -M:System.Linq.Enumerable.Min``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) -M:System.Linq.Enumerable.OfType``1(System.Collections.IEnumerable) -M:System.Linq.Enumerable.Order``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Order``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) -M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) -M:System.Linq.Enumerable.OrderByDescending``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.OrderByDescending``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) -M:System.Linq.Enumerable.OrderDescending``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.OrderDescending``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0}) -M:System.Linq.Enumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.Range(System.Int32,System.Int32) -M:System.Linq.Enumerable.Repeat``1(``0,System.Int32) -M:System.Linq.Enumerable.Reverse``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Select``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.Select``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,``1}) -M:System.Linq.Enumerable.SelectMany``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}}) -M:System.Linq.Enumerable.SelectMany``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Collections.Generic.IEnumerable{``1}}) -M:System.Linq.Enumerable.SelectMany``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) -M:System.Linq.Enumerable.SelectMany``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Collections.Generic.IEnumerable{``1}},System.Func{``0,``1,``2}) -M:System.Linq.Enumerable.SequenceEqual``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.SequenceEqual``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},``0) -M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.SingleOrDefault``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},``0) -M:System.Linq.Enumerable.Skip``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.SkipWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.SkipWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Decimal}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Double}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Int32}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Int64}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Sum(System.Collections.Generic.IEnumerable{System.Single}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Decimal}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Double}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Decimal}}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Double}}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int32}}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Int64}}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Nullable{System.Single}}) -M:System.Linq.Enumerable.Sum``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Single}) -M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Range) -M:System.Linq.Enumerable.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) -M:System.Linq.Enumerable.TakeWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.TakeWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) -M:System.Linq.Enumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) -M:System.Linq.Enumerable.ThenByDescending``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.ThenByDescending``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) -M:System.Linq.Enumerable.ToArray``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) -M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}}) -M:System.Linq.Enumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.ToDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) -M:System.Linq.Enumerable.ToDictionary``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.ToList``1(System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.ToLookup``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.ToLookup``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.ToLookup``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) -M:System.Linq.Enumerable.ToLookup``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.TryGetNonEnumeratedCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32@) -M:System.Linq.Enumerable.Union``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}) -M:System.Linq.Enumerable.Union``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) -M:System.Linq.Enumerable.UnionBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) -M:System.Linq.Enumerable.UnionBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) -M:System.Linq.Enumerable.Where``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean}) -M:System.Linq.Enumerable.Where``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean}) -M:System.Linq.Enumerable.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1}) -M:System.Linq.Enumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2}) -M:System.Linq.Enumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2}) -M:System.Linq.IGrouping`2.get_Key -M:System.Linq.ILookup`2.Contains(`0) -M:System.Linq.ILookup`2.get_Count -M:System.Linq.ILookup`2.get_Item(`0) -M:System.Linq.IOrderedEnumerable`1.CreateOrderedEnumerable``1(System.Func{`0,``0},System.Collections.Generic.IComparer{``0},System.Boolean) -M:System.Linq.Lookup`2.ApplyResultSelector``1(System.Func{`0,System.Collections.Generic.IEnumerable{`1},``0}) -M:System.Linq.Lookup`2.Contains(`0) -M:System.Linq.Lookup`2.get_Count -M:System.Linq.Lookup`2.get_Item(`0) -M:System.Linq.Lookup`2.GetEnumerator -T:System.Linq.Enumerable -T:System.Linq.IGrouping`2 -T:System.Linq.ILookup`2 -T:System.Linq.IOrderedEnumerable`1 -T:System.Linq.Lookup`2 \ No newline at end of file diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt deleted file mode 100644 index 9c3c4baadbf5d..0000000000000 --- a/src/Tools/SemanticSearch/ReferenceAssemblies/Baselines/System.Runtime.txt +++ /dev/null @@ -1,7717 +0,0 @@ -F:System.AttributeTargets.All -F:System.AttributeTargets.Assembly -F:System.AttributeTargets.Class -F:System.AttributeTargets.Constructor -F:System.AttributeTargets.Delegate -F:System.AttributeTargets.Enum -F:System.AttributeTargets.Event -F:System.AttributeTargets.Field -F:System.AttributeTargets.GenericParameter -F:System.AttributeTargets.Interface -F:System.AttributeTargets.Method -F:System.AttributeTargets.Module -F:System.AttributeTargets.Parameter -F:System.AttributeTargets.Property -F:System.AttributeTargets.ReturnValue -F:System.AttributeTargets.Struct -F:System.Base64FormattingOptions.InsertLineBreaks -F:System.Base64FormattingOptions.None -F:System.BitConverter.IsLittleEndian -F:System.Boolean.FalseString -F:System.Boolean.TrueString -F:System.Buffers.OperationStatus.DestinationTooSmall -F:System.Buffers.OperationStatus.Done -F:System.Buffers.OperationStatus.InvalidData -F:System.Buffers.OperationStatus.NeedMoreData -F:System.Byte.MaxValue -F:System.Byte.MinValue -F:System.Char.MaxValue -F:System.Char.MinValue -F:System.CodeDom.Compiler.IndentedTextWriter.DefaultTabString -F:System.Collections.Comparer.Default -F:System.Collections.Comparer.DefaultInvariant -F:System.ComponentModel.EditorBrowsableState.Advanced -F:System.ComponentModel.EditorBrowsableState.Always -F:System.ComponentModel.EditorBrowsableState.Never -F:System.Configuration.Assemblies.AssemblyHashAlgorithm.MD5 -F:System.Configuration.Assemblies.AssemblyHashAlgorithm.None -F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA1 -F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA256 -F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA384 -F:System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA512 -F:System.Configuration.Assemblies.AssemblyVersionCompatibility.SameDomain -F:System.Configuration.Assemblies.AssemblyVersionCompatibility.SameMachine -F:System.Configuration.Assemblies.AssemblyVersionCompatibility.SameProcess -F:System.Convert.DBNull -F:System.DateTime.MaxValue -F:System.DateTime.MinValue -F:System.DateTime.UnixEpoch -F:System.DateTimeKind.Local -F:System.DateTimeKind.Unspecified -F:System.DateTimeKind.Utc -F:System.DateTimeOffset.MaxValue -F:System.DateTimeOffset.MinValue -F:System.DateTimeOffset.UnixEpoch -F:System.DayOfWeek.Friday -F:System.DayOfWeek.Monday -F:System.DayOfWeek.Saturday -F:System.DayOfWeek.Sunday -F:System.DayOfWeek.Thursday -F:System.DayOfWeek.Tuesday -F:System.DayOfWeek.Wednesday -F:System.DBNull.Value -F:System.Decimal.MaxValue -F:System.Decimal.MinusOne -F:System.Decimal.MinValue -F:System.Decimal.One -F:System.Decimal.Zero -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.None -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor -F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.CompositeFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.DateOnlyFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.DateTimeFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.EnumFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.GuidFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Json -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.NumericFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.TimeOnlyFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.TimeSpanFormat -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Uri -F:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Xml -F:System.Diagnostics.DebuggableAttribute.DebuggingModes.Default -F:System.Diagnostics.DebuggableAttribute.DebuggingModes.DisableOptimizations -F:System.Diagnostics.DebuggableAttribute.DebuggingModes.EnableEditAndContinue -F:System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints -F:System.Diagnostics.DebuggableAttribute.DebuggingModes.None -F:System.Diagnostics.DebuggerBrowsableState.Collapsed -F:System.Diagnostics.DebuggerBrowsableState.Never -F:System.Diagnostics.DebuggerBrowsableState.RootHidden -F:System.Diagnostics.Stopwatch.Frequency -F:System.Diagnostics.Stopwatch.IsHighResolution -F:System.Double.E -F:System.Double.Epsilon -F:System.Double.MaxValue -F:System.Double.MinValue -F:System.Double.NaN -F:System.Double.NegativeInfinity -F:System.Double.NegativeZero -F:System.Double.Pi -F:System.Double.PositiveInfinity -F:System.Double.Tau -F:System.EventArgs.Empty -F:System.GenericUriParserOptions.AllowEmptyAuthority -F:System.GenericUriParserOptions.Default -F:System.GenericUriParserOptions.DontCompressPath -F:System.GenericUriParserOptions.DontConvertPathBackslashes -F:System.GenericUriParserOptions.DontUnescapePathDotsAndSlashes -F:System.GenericUriParserOptions.GenericAuthority -F:System.GenericUriParserOptions.Idn -F:System.GenericUriParserOptions.IriParsing -F:System.GenericUriParserOptions.NoFragment -F:System.GenericUriParserOptions.NoPort -F:System.GenericUriParserOptions.NoQuery -F:System.GenericUriParserOptions.NoUserInfo -F:System.Globalization.Calendar.CurrentEra -F:System.Globalization.CalendarAlgorithmType.LunarCalendar -F:System.Globalization.CalendarAlgorithmType.LunisolarCalendar -F:System.Globalization.CalendarAlgorithmType.SolarCalendar -F:System.Globalization.CalendarAlgorithmType.Unknown -F:System.Globalization.CalendarWeekRule.FirstDay -F:System.Globalization.CalendarWeekRule.FirstFourDayWeek -F:System.Globalization.CalendarWeekRule.FirstFullWeek -F:System.Globalization.ChineseLunisolarCalendar.ChineseEra -F:System.Globalization.CompareOptions.IgnoreCase -F:System.Globalization.CompareOptions.IgnoreKanaType -F:System.Globalization.CompareOptions.IgnoreNonSpace -F:System.Globalization.CompareOptions.IgnoreSymbols -F:System.Globalization.CompareOptions.IgnoreWidth -F:System.Globalization.CompareOptions.None -F:System.Globalization.CompareOptions.Ordinal -F:System.Globalization.CompareOptions.OrdinalIgnoreCase -F:System.Globalization.CompareOptions.StringSort -F:System.Globalization.CultureTypes.AllCultures -F:System.Globalization.CultureTypes.FrameworkCultures -F:System.Globalization.CultureTypes.InstalledWin32Cultures -F:System.Globalization.CultureTypes.NeutralCultures -F:System.Globalization.CultureTypes.ReplacementCultures -F:System.Globalization.CultureTypes.SpecificCultures -F:System.Globalization.CultureTypes.UserCustomCulture -F:System.Globalization.CultureTypes.WindowsOnlyCultures -F:System.Globalization.DateTimeStyles.AdjustToUniversal -F:System.Globalization.DateTimeStyles.AllowInnerWhite -F:System.Globalization.DateTimeStyles.AllowLeadingWhite -F:System.Globalization.DateTimeStyles.AllowTrailingWhite -F:System.Globalization.DateTimeStyles.AllowWhiteSpaces -F:System.Globalization.DateTimeStyles.AssumeLocal -F:System.Globalization.DateTimeStyles.AssumeUniversal -F:System.Globalization.DateTimeStyles.NoCurrentDateDefault -F:System.Globalization.DateTimeStyles.None -F:System.Globalization.DateTimeStyles.RoundtripKind -F:System.Globalization.DigitShapes.Context -F:System.Globalization.DigitShapes.NativeNational -F:System.Globalization.DigitShapes.None -F:System.Globalization.GregorianCalendar.ADEra -F:System.Globalization.GregorianCalendarTypes.Arabic -F:System.Globalization.GregorianCalendarTypes.Localized -F:System.Globalization.GregorianCalendarTypes.MiddleEastFrench -F:System.Globalization.GregorianCalendarTypes.TransliteratedEnglish -F:System.Globalization.GregorianCalendarTypes.TransliteratedFrench -F:System.Globalization.GregorianCalendarTypes.USEnglish -F:System.Globalization.HebrewCalendar.HebrewEra -F:System.Globalization.HijriCalendar.HijriEra -F:System.Globalization.JapaneseLunisolarCalendar.JapaneseEra -F:System.Globalization.JulianCalendar.JulianEra -F:System.Globalization.KoreanCalendar.KoreanEra -F:System.Globalization.KoreanLunisolarCalendar.GregorianEra -F:System.Globalization.NumberStyles.AllowBinarySpecifier -F:System.Globalization.NumberStyles.AllowCurrencySymbol -F:System.Globalization.NumberStyles.AllowDecimalPoint -F:System.Globalization.NumberStyles.AllowExponent -F:System.Globalization.NumberStyles.AllowHexSpecifier -F:System.Globalization.NumberStyles.AllowLeadingSign -F:System.Globalization.NumberStyles.AllowLeadingWhite -F:System.Globalization.NumberStyles.AllowParentheses -F:System.Globalization.NumberStyles.AllowThousands -F:System.Globalization.NumberStyles.AllowTrailingSign -F:System.Globalization.NumberStyles.AllowTrailingWhite -F:System.Globalization.NumberStyles.Any -F:System.Globalization.NumberStyles.BinaryNumber -F:System.Globalization.NumberStyles.Currency -F:System.Globalization.NumberStyles.Float -F:System.Globalization.NumberStyles.HexNumber -F:System.Globalization.NumberStyles.Integer -F:System.Globalization.NumberStyles.None -F:System.Globalization.NumberStyles.Number -F:System.Globalization.PersianCalendar.PersianEra -F:System.Globalization.ThaiBuddhistCalendar.ThaiBuddhistEra -F:System.Globalization.TimeSpanStyles.AssumeNegative -F:System.Globalization.TimeSpanStyles.None -F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra -F:System.Globalization.UnicodeCategory.ClosePunctuation -F:System.Globalization.UnicodeCategory.ConnectorPunctuation -F:System.Globalization.UnicodeCategory.Control -F:System.Globalization.UnicodeCategory.CurrencySymbol -F:System.Globalization.UnicodeCategory.DashPunctuation -F:System.Globalization.UnicodeCategory.DecimalDigitNumber -F:System.Globalization.UnicodeCategory.EnclosingMark -F:System.Globalization.UnicodeCategory.FinalQuotePunctuation -F:System.Globalization.UnicodeCategory.Format -F:System.Globalization.UnicodeCategory.InitialQuotePunctuation -F:System.Globalization.UnicodeCategory.LetterNumber -F:System.Globalization.UnicodeCategory.LineSeparator -F:System.Globalization.UnicodeCategory.LowercaseLetter -F:System.Globalization.UnicodeCategory.MathSymbol -F:System.Globalization.UnicodeCategory.ModifierLetter -F:System.Globalization.UnicodeCategory.ModifierSymbol -F:System.Globalization.UnicodeCategory.NonSpacingMark -F:System.Globalization.UnicodeCategory.OpenPunctuation -F:System.Globalization.UnicodeCategory.OtherLetter -F:System.Globalization.UnicodeCategory.OtherNotAssigned -F:System.Globalization.UnicodeCategory.OtherNumber -F:System.Globalization.UnicodeCategory.OtherPunctuation -F:System.Globalization.UnicodeCategory.OtherSymbol -F:System.Globalization.UnicodeCategory.ParagraphSeparator -F:System.Globalization.UnicodeCategory.PrivateUse -F:System.Globalization.UnicodeCategory.SpaceSeparator -F:System.Globalization.UnicodeCategory.SpacingCombiningMark -F:System.Globalization.UnicodeCategory.Surrogate -F:System.Globalization.UnicodeCategory.TitlecaseLetter -F:System.Globalization.UnicodeCategory.UppercaseLetter -F:System.Guid.Empty -F:System.Int16.MaxValue -F:System.Int16.MinValue -F:System.Int32.MaxValue -F:System.Int32.MinValue -F:System.Int64.MaxValue -F:System.Int64.MinValue -F:System.IntPtr.Zero -F:System.Math.E -F:System.Math.PI -F:System.Math.Tau -F:System.MathF.E -F:System.MathF.PI -F:System.MathF.Tau -F:System.MidpointRounding.AwayFromZero -F:System.MidpointRounding.ToEven -F:System.MidpointRounding.ToNegativeInfinity -F:System.MidpointRounding.ToPositiveInfinity -F:System.MidpointRounding.ToZero -F:System.MissingMemberException.ClassName -F:System.MissingMemberException.MemberName -F:System.MissingMemberException.Signature -F:System.ModuleHandle.EmptyHandle -F:System.PlatformID.MacOSX -F:System.PlatformID.Other -F:System.PlatformID.Unix -F:System.PlatformID.Win32NT -F:System.PlatformID.Win32S -F:System.PlatformID.Win32Windows -F:System.PlatformID.WinCE -F:System.PlatformID.Xbox -F:System.Runtime.CompilerServices.CompilationRelaxations.NoStringInterning -F:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.RefStructs -F:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.RequiredMembers -F:System.Runtime.CompilerServices.LoadHint.Always -F:System.Runtime.CompilerServices.LoadHint.Default -F:System.Runtime.CompilerServices.LoadHint.Sometimes -F:System.Runtime.CompilerServices.MethodCodeType.IL -F:System.Runtime.CompilerServices.MethodCodeType.Native -F:System.Runtime.CompilerServices.MethodCodeType.OPTIL -F:System.Runtime.CompilerServices.MethodCodeType.Runtime -F:System.Runtime.CompilerServices.MethodImplAttribute.MethodCodeType -F:System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining -F:System.Runtime.CompilerServices.MethodImplOptions.AggressiveOptimization -F:System.Runtime.CompilerServices.MethodImplOptions.ForwardRef -F:System.Runtime.CompilerServices.MethodImplOptions.InternalCall -F:System.Runtime.CompilerServices.MethodImplOptions.NoInlining -F:System.Runtime.CompilerServices.MethodImplOptions.NoOptimization -F:System.Runtime.CompilerServices.MethodImplOptions.PreserveSig -F:System.Runtime.CompilerServices.MethodImplOptions.Synchronized -F:System.Runtime.CompilerServices.MethodImplOptions.Unmanaged -F:System.Runtime.CompilerServices.NullableAttribute.NullableFlags -F:System.Runtime.CompilerServices.NullableContextAttribute.Flag -F:System.Runtime.CompilerServices.NullablePublicOnlyAttribute.IncludesInternals -F:System.Runtime.CompilerServices.RuntimeFeature.ByRefFields -F:System.Runtime.CompilerServices.RuntimeFeature.CovariantReturnsOfClasses -F:System.Runtime.CompilerServices.RuntimeFeature.DefaultImplementationsOfInterfaces -F:System.Runtime.CompilerServices.RuntimeFeature.NumericIntPtr -F:System.Runtime.CompilerServices.RuntimeFeature.PortablePdb -F:System.Runtime.CompilerServices.RuntimeFeature.UnmanagedSignatureCallingConvention -F:System.Runtime.CompilerServices.RuntimeFeature.VirtualStaticsInInterfaces -F:System.Runtime.CompilerServices.StrongBox`1.Value -F:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor -F:System.Runtime.CompilerServices.UnsafeAccessorKind.Field -F:System.Runtime.CompilerServices.UnsafeAccessorKind.Method -F:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticField -F:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticMethod -F:System.SByte.MaxValue -F:System.SByte.MinValue -F:System.Single.E -F:System.Single.Epsilon -F:System.Single.MaxValue -F:System.Single.MinValue -F:System.Single.NaN -F:System.Single.NegativeInfinity -F:System.Single.NegativeZero -F:System.Single.Pi -F:System.Single.PositiveInfinity -F:System.Single.Tau -F:System.String.Empty -F:System.StringComparison.CurrentCulture -F:System.StringComparison.CurrentCultureIgnoreCase -F:System.StringComparison.InvariantCulture -F:System.StringComparison.InvariantCultureIgnoreCase -F:System.StringComparison.Ordinal -F:System.StringComparison.OrdinalIgnoreCase -F:System.StringSplitOptions.None -F:System.StringSplitOptions.RemoveEmptyEntries -F:System.StringSplitOptions.TrimEntries -F:System.Text.NormalizationForm.FormC -F:System.Text.NormalizationForm.FormD -F:System.Text.NormalizationForm.FormKC -F:System.Text.NormalizationForm.FormKD -F:System.Threading.Tasks.ConfigureAwaitOptions.ContinueOnCapturedContext -F:System.Threading.Tasks.ConfigureAwaitOptions.ForceYielding -F:System.Threading.Tasks.ConfigureAwaitOptions.None -F:System.Threading.Tasks.ConfigureAwaitOptions.SuppressThrowing -F:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.FlowExecutionContext -F:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.None -F:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags.UseSchedulingContext -F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Canceled -F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Faulted -F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Pending -F:System.Threading.Tasks.Sources.ValueTaskSourceStatus.Succeeded -F:System.Threading.Tasks.TaskContinuationOptions.AttachedToParent -F:System.Threading.Tasks.TaskContinuationOptions.DenyChildAttach -F:System.Threading.Tasks.TaskContinuationOptions.ExecuteSynchronously -F:System.Threading.Tasks.TaskContinuationOptions.HideScheduler -F:System.Threading.Tasks.TaskContinuationOptions.LazyCancellation -F:System.Threading.Tasks.TaskContinuationOptions.LongRunning -F:System.Threading.Tasks.TaskContinuationOptions.None -F:System.Threading.Tasks.TaskContinuationOptions.NotOnCanceled -F:System.Threading.Tasks.TaskContinuationOptions.NotOnFaulted -F:System.Threading.Tasks.TaskContinuationOptions.NotOnRanToCompletion -F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnCanceled -F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnFaulted -F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnRanToCompletion -F:System.Threading.Tasks.TaskContinuationOptions.PreferFairness -F:System.Threading.Tasks.TaskContinuationOptions.RunContinuationsAsynchronously -F:System.Threading.Tasks.TaskCreationOptions.AttachedToParent -F:System.Threading.Tasks.TaskCreationOptions.DenyChildAttach -F:System.Threading.Tasks.TaskCreationOptions.HideScheduler -F:System.Threading.Tasks.TaskCreationOptions.LongRunning -F:System.Threading.Tasks.TaskCreationOptions.None -F:System.Threading.Tasks.TaskCreationOptions.PreferFairness -F:System.Threading.Tasks.TaskCreationOptions.RunContinuationsAsynchronously -F:System.Threading.Tasks.TaskStatus.Canceled -F:System.Threading.Tasks.TaskStatus.Created -F:System.Threading.Tasks.TaskStatus.Faulted -F:System.Threading.Tasks.TaskStatus.RanToCompletion -F:System.Threading.Tasks.TaskStatus.Running -F:System.Threading.Tasks.TaskStatus.WaitingForActivation -F:System.Threading.Tasks.TaskStatus.WaitingForChildrenToComplete -F:System.Threading.Tasks.TaskStatus.WaitingToRun -F:System.TimeSpan.MaxValue -F:System.TimeSpan.MinValue -F:System.TimeSpan.NanosecondsPerTick -F:System.TimeSpan.TicksPerDay -F:System.TimeSpan.TicksPerHour -F:System.TimeSpan.TicksPerMicrosecond -F:System.TimeSpan.TicksPerMillisecond -F:System.TimeSpan.TicksPerMinute -F:System.TimeSpan.TicksPerSecond -F:System.TimeSpan.Zero -F:System.Type.Delimiter -F:System.Type.EmptyTypes -F:System.Type.FilterAttribute -F:System.Type.FilterName -F:System.Type.FilterNameIgnoreCase -F:System.Type.Missing -F:System.TypeCode.Boolean -F:System.TypeCode.Byte -F:System.TypeCode.Char -F:System.TypeCode.DateTime -F:System.TypeCode.DBNull -F:System.TypeCode.Decimal -F:System.TypeCode.Double -F:System.TypeCode.Empty -F:System.TypeCode.Int16 -F:System.TypeCode.Int32 -F:System.TypeCode.Int64 -F:System.TypeCode.Object -F:System.TypeCode.SByte -F:System.TypeCode.Single -F:System.TypeCode.String -F:System.TypeCode.UInt16 -F:System.TypeCode.UInt32 -F:System.TypeCode.UInt64 -F:System.UInt16.MaxValue -F:System.UInt16.MinValue -F:System.UInt32.MaxValue -F:System.UInt32.MinValue -F:System.UInt64.MaxValue -F:System.UInt64.MinValue -F:System.UIntPtr.Zero -F:System.Uri.SchemeDelimiter -F:System.Uri.UriSchemeFile -F:System.Uri.UriSchemeFtp -F:System.Uri.UriSchemeFtps -F:System.Uri.UriSchemeGopher -F:System.Uri.UriSchemeHttp -F:System.Uri.UriSchemeHttps -F:System.Uri.UriSchemeMailto -F:System.Uri.UriSchemeNetPipe -F:System.Uri.UriSchemeNetTcp -F:System.Uri.UriSchemeNews -F:System.Uri.UriSchemeNntp -F:System.Uri.UriSchemeSftp -F:System.Uri.UriSchemeSsh -F:System.Uri.UriSchemeTelnet -F:System.Uri.UriSchemeWs -F:System.Uri.UriSchemeWss -F:System.UriComponents.AbsoluteUri -F:System.UriComponents.Fragment -F:System.UriComponents.Host -F:System.UriComponents.HostAndPort -F:System.UriComponents.HttpRequestUrl -F:System.UriComponents.KeepDelimiter -F:System.UriComponents.NormalizedHost -F:System.UriComponents.Path -F:System.UriComponents.PathAndQuery -F:System.UriComponents.Port -F:System.UriComponents.Query -F:System.UriComponents.Scheme -F:System.UriComponents.SchemeAndServer -F:System.UriComponents.SerializationInfoString -F:System.UriComponents.StrongAuthority -F:System.UriComponents.StrongPort -F:System.UriComponents.UserInfo -F:System.UriFormat.SafeUnescaped -F:System.UriFormat.Unescaped -F:System.UriFormat.UriEscaped -F:System.UriHostNameType.Basic -F:System.UriHostNameType.Dns -F:System.UriHostNameType.IPv4 -F:System.UriHostNameType.IPv6 -F:System.UriHostNameType.Unknown -F:System.UriKind.Absolute -F:System.UriKind.Relative -F:System.UriKind.RelativeOrAbsolute -F:System.UriPartial.Authority -F:System.UriPartial.Path -F:System.UriPartial.Query -F:System.UriPartial.Scheme -F:System.ValueTuple`1.Item1 -F:System.ValueTuple`2.Item1 -F:System.ValueTuple`2.Item2 -F:System.ValueTuple`3.Item1 -F:System.ValueTuple`3.Item2 -F:System.ValueTuple`3.Item3 -F:System.ValueTuple`4.Item1 -F:System.ValueTuple`4.Item2 -F:System.ValueTuple`4.Item3 -F:System.ValueTuple`4.Item4 -F:System.ValueTuple`5.Item1 -F:System.ValueTuple`5.Item2 -F:System.ValueTuple`5.Item3 -F:System.ValueTuple`5.Item4 -F:System.ValueTuple`5.Item5 -F:System.ValueTuple`6.Item1 -F:System.ValueTuple`6.Item2 -F:System.ValueTuple`6.Item3 -F:System.ValueTuple`6.Item4 -F:System.ValueTuple`6.Item5 -F:System.ValueTuple`6.Item6 -F:System.ValueTuple`7.Item1 -F:System.ValueTuple`7.Item2 -F:System.ValueTuple`7.Item3 -F:System.ValueTuple`7.Item4 -F:System.ValueTuple`7.Item5 -F:System.ValueTuple`7.Item6 -F:System.ValueTuple`7.Item7 -F:System.ValueTuple`8.Item1 -F:System.ValueTuple`8.Item2 -F:System.ValueTuple`8.Item3 -F:System.ValueTuple`8.Item4 -F:System.ValueTuple`8.Item5 -F:System.ValueTuple`8.Item6 -F:System.ValueTuple`8.Item7 -F:System.ValueTuple`8.Rest -M:System.AccessViolationException.#ctor -M:System.AccessViolationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.AccessViolationException.#ctor(System.String) -M:System.AccessViolationException.#ctor(System.String,System.Exception) -M:System.Action.#ctor(System.Object,System.IntPtr) -M:System.Action.BeginInvoke(System.AsyncCallback,System.Object) -M:System.Action.EndInvoke(System.IAsyncResult) -M:System.Action.Invoke -M:System.Action`1.#ctor(System.Object,System.IntPtr) -M:System.Action`1.BeginInvoke(`0,System.AsyncCallback,System.Object) -M:System.Action`1.EndInvoke(System.IAsyncResult) -M:System.Action`1.Invoke(`0) -M:System.Action`10.#ctor(System.Object,System.IntPtr) -M:System.Action`10.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,System.AsyncCallback,System.Object) -M:System.Action`10.EndInvoke(System.IAsyncResult) -M:System.Action`10.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9) -M:System.Action`11.#ctor(System.Object,System.IntPtr) -M:System.Action`11.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,System.AsyncCallback,System.Object) -M:System.Action`11.EndInvoke(System.IAsyncResult) -M:System.Action`11.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10) -M:System.Action`12.#ctor(System.Object,System.IntPtr) -M:System.Action`12.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,System.AsyncCallback,System.Object) -M:System.Action`12.EndInvoke(System.IAsyncResult) -M:System.Action`12.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11) -M:System.Action`13.#ctor(System.Object,System.IntPtr) -M:System.Action`13.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,System.AsyncCallback,System.Object) -M:System.Action`13.EndInvoke(System.IAsyncResult) -M:System.Action`13.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12) -M:System.Action`14.#ctor(System.Object,System.IntPtr) -M:System.Action`14.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,System.AsyncCallback,System.Object) -M:System.Action`14.EndInvoke(System.IAsyncResult) -M:System.Action`14.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13) -M:System.Action`15.#ctor(System.Object,System.IntPtr) -M:System.Action`15.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,System.AsyncCallback,System.Object) -M:System.Action`15.EndInvoke(System.IAsyncResult) -M:System.Action`15.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14) -M:System.Action`16.#ctor(System.Object,System.IntPtr) -M:System.Action`16.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15,System.AsyncCallback,System.Object) -M:System.Action`16.EndInvoke(System.IAsyncResult) -M:System.Action`16.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15) -M:System.Action`2.#ctor(System.Object,System.IntPtr) -M:System.Action`2.BeginInvoke(`0,`1,System.AsyncCallback,System.Object) -M:System.Action`2.EndInvoke(System.IAsyncResult) -M:System.Action`2.Invoke(`0,`1) -M:System.Action`3.#ctor(System.Object,System.IntPtr) -M:System.Action`3.BeginInvoke(`0,`1,`2,System.AsyncCallback,System.Object) -M:System.Action`3.EndInvoke(System.IAsyncResult) -M:System.Action`3.Invoke(`0,`1,`2) -M:System.Action`4.#ctor(System.Object,System.IntPtr) -M:System.Action`4.BeginInvoke(`0,`1,`2,`3,System.AsyncCallback,System.Object) -M:System.Action`4.EndInvoke(System.IAsyncResult) -M:System.Action`4.Invoke(`0,`1,`2,`3) -M:System.Action`5.#ctor(System.Object,System.IntPtr) -M:System.Action`5.BeginInvoke(`0,`1,`2,`3,`4,System.AsyncCallback,System.Object) -M:System.Action`5.EndInvoke(System.IAsyncResult) -M:System.Action`5.Invoke(`0,`1,`2,`3,`4) -M:System.Action`6.#ctor(System.Object,System.IntPtr) -M:System.Action`6.BeginInvoke(`0,`1,`2,`3,`4,`5,System.AsyncCallback,System.Object) -M:System.Action`6.EndInvoke(System.IAsyncResult) -M:System.Action`6.Invoke(`0,`1,`2,`3,`4,`5) -M:System.Action`7.#ctor(System.Object,System.IntPtr) -M:System.Action`7.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,System.AsyncCallback,System.Object) -M:System.Action`7.EndInvoke(System.IAsyncResult) -M:System.Action`7.Invoke(`0,`1,`2,`3,`4,`5,`6) -M:System.Action`8.#ctor(System.Object,System.IntPtr) -M:System.Action`8.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,System.AsyncCallback,System.Object) -M:System.Action`8.EndInvoke(System.IAsyncResult) -M:System.Action`8.Invoke(`0,`1,`2,`3,`4,`5,`6,`7) -M:System.Action`9.#ctor(System.Object,System.IntPtr) -M:System.Action`9.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,System.AsyncCallback,System.Object) -M:System.Action`9.EndInvoke(System.IAsyncResult) -M:System.Action`9.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8) -M:System.AggregateException.#ctor -M:System.AggregateException.#ctor(System.Collections.Generic.IEnumerable{System.Exception}) -M:System.AggregateException.#ctor(System.Exception[]) -M:System.AggregateException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.AggregateException.#ctor(System.String) -M:System.AggregateException.#ctor(System.String,System.Collections.Generic.IEnumerable{System.Exception}) -M:System.AggregateException.#ctor(System.String,System.Exception) -M:System.AggregateException.#ctor(System.String,System.Exception[]) -M:System.AggregateException.Flatten -M:System.AggregateException.get_InnerExceptions -M:System.AggregateException.get_Message -M:System.AggregateException.GetBaseException -M:System.AggregateException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.AggregateException.Handle(System.Func{System.Exception,System.Boolean}) -M:System.AggregateException.ToString -M:System.ApplicationException.#ctor -M:System.ApplicationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ApplicationException.#ctor(System.String) -M:System.ApplicationException.#ctor(System.String,System.Exception) -M:System.ApplicationId.#ctor(System.Byte[],System.String,System.Version,System.String,System.String) -M:System.ApplicationId.Copy -M:System.ApplicationId.Equals(System.Object) -M:System.ApplicationId.get_Culture -M:System.ApplicationId.get_Name -M:System.ApplicationId.get_ProcessorArchitecture -M:System.ApplicationId.get_PublicKeyToken -M:System.ApplicationId.get_Version -M:System.ApplicationId.GetHashCode -M:System.ApplicationId.ToString -M:System.ArgIterator.#ctor(System.RuntimeArgumentHandle) -M:System.ArgIterator.#ctor(System.RuntimeArgumentHandle,System.Void*) -M:System.ArgIterator.End -M:System.ArgIterator.Equals(System.Object) -M:System.ArgIterator.GetHashCode -M:System.ArgIterator.GetNextArg -M:System.ArgIterator.GetNextArg(System.RuntimeTypeHandle) -M:System.ArgIterator.GetNextArgType -M:System.ArgIterator.GetRemainingCount -M:System.ArgumentException.#ctor -M:System.ArgumentException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArgumentException.#ctor(System.String) -M:System.ArgumentException.#ctor(System.String,System.Exception) -M:System.ArgumentException.#ctor(System.String,System.String) -M:System.ArgumentException.#ctor(System.String,System.String,System.Exception) -M:System.ArgumentException.get_Message -M:System.ArgumentException.get_ParamName -M:System.ArgumentException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArgumentException.ThrowIfNullOrEmpty(System.String,System.String) -M:System.ArgumentException.ThrowIfNullOrWhiteSpace(System.String,System.String) -M:System.ArgumentNullException.#ctor -M:System.ArgumentNullException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArgumentNullException.#ctor(System.String) -M:System.ArgumentNullException.#ctor(System.String,System.Exception) -M:System.ArgumentNullException.#ctor(System.String,System.String) -M:System.ArgumentNullException.ThrowIfNull(System.Object,System.String) -M:System.ArgumentNullException.ThrowIfNull(System.Void*,System.String) -M:System.ArgumentOutOfRangeException.#ctor -M:System.ArgumentOutOfRangeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArgumentOutOfRangeException.#ctor(System.String) -M:System.ArgumentOutOfRangeException.#ctor(System.String,System.Exception) -M:System.ArgumentOutOfRangeException.#ctor(System.String,System.Object,System.String) -M:System.ArgumentOutOfRangeException.#ctor(System.String,System.String) -M:System.ArgumentOutOfRangeException.get_ActualValue -M:System.ArgumentOutOfRangeException.get_Message -M:System.ArgumentOutOfRangeException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArgumentOutOfRangeException.ThrowIfEqual``1(``0,``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfGreaterThan``1(``0,``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual``1(``0,``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfLessThan``1(``0,``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfLessThanOrEqual``1(``0,``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfNegative``1(``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfNegativeOrZero``1(``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfNotEqual``1(``0,``0,System.String) -M:System.ArgumentOutOfRangeException.ThrowIfZero``1(``0,System.String) -M:System.ArithmeticException.#ctor -M:System.ArithmeticException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArithmeticException.#ctor(System.String) -M:System.ArithmeticException.#ctor(System.String,System.Exception) -M:System.Array.AsReadOnly``1(``0[]) -M:System.Array.BinarySearch(System.Array,System.Int32,System.Int32,System.Object) -M:System.Array.BinarySearch(System.Array,System.Int32,System.Int32,System.Object,System.Collections.IComparer) -M:System.Array.BinarySearch(System.Array,System.Object) -M:System.Array.BinarySearch(System.Array,System.Object,System.Collections.IComparer) -M:System.Array.BinarySearch``1(``0[],``0) -M:System.Array.BinarySearch``1(``0[],``0,System.Collections.Generic.IComparer{``0}) -M:System.Array.BinarySearch``1(``0[],System.Int32,System.Int32,``0) -M:System.Array.BinarySearch``1(``0[],System.Int32,System.Int32,``0,System.Collections.Generic.IComparer{``0}) -M:System.Array.Clear(System.Array) -M:System.Array.Clear(System.Array,System.Int32,System.Int32) -M:System.Array.Clone -M:System.Array.ConstrainedCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) -M:System.Array.ConvertAll``2(``0[],System.Converter{``0,``1}) -M:System.Array.Copy(System.Array,System.Array,System.Int32) -M:System.Array.Copy(System.Array,System.Array,System.Int64) -M:System.Array.Copy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) -M:System.Array.Copy(System.Array,System.Int64,System.Array,System.Int64,System.Int64) -M:System.Array.CopyTo(System.Array,System.Int32) -M:System.Array.CopyTo(System.Array,System.Int64) -M:System.Array.CreateInstance(System.Type,System.Int32) -M:System.Array.CreateInstance(System.Type,System.Int32,System.Int32) -M:System.Array.CreateInstance(System.Type,System.Int32,System.Int32,System.Int32) -M:System.Array.CreateInstance(System.Type,System.Int32[]) -M:System.Array.CreateInstance(System.Type,System.Int32[],System.Int32[]) -M:System.Array.CreateInstance(System.Type,System.Int64[]) -M:System.Array.Empty``1 -M:System.Array.Exists``1(``0[],System.Predicate{``0}) -M:System.Array.Fill``1(``0[],``0) -M:System.Array.Fill``1(``0[],``0,System.Int32,System.Int32) -M:System.Array.Find``1(``0[],System.Predicate{``0}) -M:System.Array.FindAll``1(``0[],System.Predicate{``0}) -M:System.Array.FindIndex``1(``0[],System.Int32,System.Int32,System.Predicate{``0}) -M:System.Array.FindIndex``1(``0[],System.Int32,System.Predicate{``0}) -M:System.Array.FindIndex``1(``0[],System.Predicate{``0}) -M:System.Array.FindLast``1(``0[],System.Predicate{``0}) -M:System.Array.FindLastIndex``1(``0[],System.Int32,System.Int32,System.Predicate{``0}) -M:System.Array.FindLastIndex``1(``0[],System.Int32,System.Predicate{``0}) -M:System.Array.FindLastIndex``1(``0[],System.Predicate{``0}) -M:System.Array.ForEach``1(``0[],System.Action{``0}) -M:System.Array.get_IsFixedSize -M:System.Array.get_IsReadOnly -M:System.Array.get_IsSynchronized -M:System.Array.get_Length -M:System.Array.get_LongLength -M:System.Array.get_MaxLength -M:System.Array.get_Rank -M:System.Array.get_SyncRoot -M:System.Array.GetEnumerator -M:System.Array.GetLength(System.Int32) -M:System.Array.GetLongLength(System.Int32) -M:System.Array.GetLowerBound(System.Int32) -M:System.Array.GetUpperBound(System.Int32) -M:System.Array.GetValue(System.Int32) -M:System.Array.GetValue(System.Int32,System.Int32) -M:System.Array.GetValue(System.Int32,System.Int32,System.Int32) -M:System.Array.GetValue(System.Int32[]) -M:System.Array.GetValue(System.Int64) -M:System.Array.GetValue(System.Int64,System.Int64) -M:System.Array.GetValue(System.Int64,System.Int64,System.Int64) -M:System.Array.GetValue(System.Int64[]) -M:System.Array.IndexOf(System.Array,System.Object) -M:System.Array.IndexOf(System.Array,System.Object,System.Int32) -M:System.Array.IndexOf(System.Array,System.Object,System.Int32,System.Int32) -M:System.Array.IndexOf``1(``0[],``0) -M:System.Array.IndexOf``1(``0[],``0,System.Int32) -M:System.Array.IndexOf``1(``0[],``0,System.Int32,System.Int32) -M:System.Array.Initialize -M:System.Array.LastIndexOf(System.Array,System.Object) -M:System.Array.LastIndexOf(System.Array,System.Object,System.Int32) -M:System.Array.LastIndexOf(System.Array,System.Object,System.Int32,System.Int32) -M:System.Array.LastIndexOf``1(``0[],``0) -M:System.Array.LastIndexOf``1(``0[],``0,System.Int32) -M:System.Array.LastIndexOf``1(``0[],``0,System.Int32,System.Int32) -M:System.Array.Resize``1(``0[]@,System.Int32) -M:System.Array.Reverse(System.Array) -M:System.Array.Reverse(System.Array,System.Int32,System.Int32) -M:System.Array.Reverse``1(``0[]) -M:System.Array.Reverse``1(``0[],System.Int32,System.Int32) -M:System.Array.SetValue(System.Object,System.Int32) -M:System.Array.SetValue(System.Object,System.Int32,System.Int32) -M:System.Array.SetValue(System.Object,System.Int32,System.Int32,System.Int32) -M:System.Array.SetValue(System.Object,System.Int32[]) -M:System.Array.SetValue(System.Object,System.Int64) -M:System.Array.SetValue(System.Object,System.Int64,System.Int64) -M:System.Array.SetValue(System.Object,System.Int64,System.Int64,System.Int64) -M:System.Array.SetValue(System.Object,System.Int64[]) -M:System.Array.Sort(System.Array) -M:System.Array.Sort(System.Array,System.Array) -M:System.Array.Sort(System.Array,System.Array,System.Collections.IComparer) -M:System.Array.Sort(System.Array,System.Array,System.Int32,System.Int32) -M:System.Array.Sort(System.Array,System.Array,System.Int32,System.Int32,System.Collections.IComparer) -M:System.Array.Sort(System.Array,System.Collections.IComparer) -M:System.Array.Sort(System.Array,System.Int32,System.Int32) -M:System.Array.Sort(System.Array,System.Int32,System.Int32,System.Collections.IComparer) -M:System.Array.Sort``1(``0[]) -M:System.Array.Sort``1(``0[],System.Collections.Generic.IComparer{``0}) -M:System.Array.Sort``1(``0[],System.Comparison{``0}) -M:System.Array.Sort``1(``0[],System.Int32,System.Int32) -M:System.Array.Sort``1(``0[],System.Int32,System.Int32,System.Collections.Generic.IComparer{``0}) -M:System.Array.Sort``2(``0[],``1[]) -M:System.Array.Sort``2(``0[],``1[],System.Collections.Generic.IComparer{``0}) -M:System.Array.Sort``2(``0[],``1[],System.Int32,System.Int32) -M:System.Array.Sort``2(``0[],``1[],System.Int32,System.Int32,System.Collections.Generic.IComparer{``0}) -M:System.Array.TrueForAll``1(``0[],System.Predicate{``0}) -M:System.ArraySegment`1.#ctor(`0[]) -M:System.ArraySegment`1.#ctor(`0[],System.Int32,System.Int32) -M:System.ArraySegment`1.CopyTo(`0[]) -M:System.ArraySegment`1.CopyTo(`0[],System.Int32) -M:System.ArraySegment`1.CopyTo(System.ArraySegment{`0}) -M:System.ArraySegment`1.Enumerator.Dispose -M:System.ArraySegment`1.Enumerator.get_Current -M:System.ArraySegment`1.Enumerator.MoveNext -M:System.ArraySegment`1.Equals(System.ArraySegment{`0}) -M:System.ArraySegment`1.Equals(System.Object) -M:System.ArraySegment`1.get_Array -M:System.ArraySegment`1.get_Count -M:System.ArraySegment`1.get_Empty -M:System.ArraySegment`1.get_Item(System.Int32) -M:System.ArraySegment`1.get_Offset -M:System.ArraySegment`1.GetEnumerator -M:System.ArraySegment`1.GetHashCode -M:System.ArraySegment`1.op_Equality(System.ArraySegment{`0},System.ArraySegment{`0}) -M:System.ArraySegment`1.op_Implicit(`0[])~System.ArraySegment{`0} -M:System.ArraySegment`1.op_Inequality(System.ArraySegment{`0},System.ArraySegment{`0}) -M:System.ArraySegment`1.set_Item(System.Int32,`0) -M:System.ArraySegment`1.Slice(System.Int32) -M:System.ArraySegment`1.Slice(System.Int32,System.Int32) -M:System.ArraySegment`1.ToArray -M:System.ArrayTypeMismatchException.#ctor -M:System.ArrayTypeMismatchException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ArrayTypeMismatchException.#ctor(System.String) -M:System.ArrayTypeMismatchException.#ctor(System.String,System.Exception) -M:System.AsyncCallback.#ctor(System.Object,System.IntPtr) -M:System.AsyncCallback.BeginInvoke(System.IAsyncResult,System.AsyncCallback,System.Object) -M:System.AsyncCallback.EndInvoke(System.IAsyncResult) -M:System.AsyncCallback.Invoke(System.IAsyncResult) -M:System.Attribute.#ctor -M:System.Attribute.Equals(System.Object) -M:System.Attribute.get_TypeId -M:System.Attribute.GetCustomAttribute(System.Reflection.Assembly,System.Type) -M:System.Attribute.GetCustomAttribute(System.Reflection.Assembly,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,System.Type) -M:System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttribute(System.Reflection.Module,System.Type) -M:System.Attribute.GetCustomAttribute(System.Reflection.Module,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,System.Type) -M:System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly) -M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Type) -M:System.Attribute.GetCustomAttributes(System.Reflection.Assembly,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo) -M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Type) -M:System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.Module) -M:System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Type) -M:System.Attribute.GetCustomAttributes(System.Reflection.Module,System.Type,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo) -M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Boolean) -M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Type) -M:System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,System.Type,System.Boolean) -M:System.Attribute.GetHashCode -M:System.Attribute.IsDefaultAttribute -M:System.Attribute.IsDefined(System.Reflection.Assembly,System.Type) -M:System.Attribute.IsDefined(System.Reflection.Assembly,System.Type,System.Boolean) -M:System.Attribute.IsDefined(System.Reflection.MemberInfo,System.Type) -M:System.Attribute.IsDefined(System.Reflection.MemberInfo,System.Type,System.Boolean) -M:System.Attribute.IsDefined(System.Reflection.Module,System.Type) -M:System.Attribute.IsDefined(System.Reflection.Module,System.Type,System.Boolean) -M:System.Attribute.IsDefined(System.Reflection.ParameterInfo,System.Type) -M:System.Attribute.IsDefined(System.Reflection.ParameterInfo,System.Type,System.Boolean) -M:System.Attribute.Match(System.Object) -M:System.AttributeUsageAttribute.#ctor(System.AttributeTargets) -M:System.AttributeUsageAttribute.get_AllowMultiple -M:System.AttributeUsageAttribute.get_Inherited -M:System.AttributeUsageAttribute.get_ValidOn -M:System.AttributeUsageAttribute.set_AllowMultiple(System.Boolean) -M:System.AttributeUsageAttribute.set_Inherited(System.Boolean) -M:System.BadImageFormatException.#ctor -M:System.BadImageFormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.BadImageFormatException.#ctor(System.String) -M:System.BadImageFormatException.#ctor(System.String,System.Exception) -M:System.BadImageFormatException.#ctor(System.String,System.String) -M:System.BadImageFormatException.#ctor(System.String,System.String,System.Exception) -M:System.BadImageFormatException.get_FileName -M:System.BadImageFormatException.get_FusionLog -M:System.BadImageFormatException.get_Message -M:System.BadImageFormatException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.BadImageFormatException.ToString -M:System.BitConverter.DoubleToInt64Bits(System.Double) -M:System.BitConverter.DoubleToUInt64Bits(System.Double) -M:System.BitConverter.GetBytes(System.Boolean) -M:System.BitConverter.GetBytes(System.Char) -M:System.BitConverter.GetBytes(System.Double) -M:System.BitConverter.GetBytes(System.Half) -M:System.BitConverter.GetBytes(System.Int16) -M:System.BitConverter.GetBytes(System.Int32) -M:System.BitConverter.GetBytes(System.Int64) -M:System.BitConverter.GetBytes(System.Single) -M:System.BitConverter.GetBytes(System.UInt16) -M:System.BitConverter.GetBytes(System.UInt32) -M:System.BitConverter.GetBytes(System.UInt64) -M:System.BitConverter.HalfToInt16Bits(System.Half) -M:System.BitConverter.HalfToUInt16Bits(System.Half) -M:System.BitConverter.Int16BitsToHalf(System.Int16) -M:System.BitConverter.Int32BitsToSingle(System.Int32) -M:System.BitConverter.Int64BitsToDouble(System.Int64) -M:System.BitConverter.SingleToInt32Bits(System.Single) -M:System.BitConverter.SingleToUInt32Bits(System.Single) -M:System.BitConverter.ToBoolean(System.Byte[],System.Int32) -M:System.BitConverter.ToBoolean(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToChar(System.Byte[],System.Int32) -M:System.BitConverter.ToChar(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToDouble(System.Byte[],System.Int32) -M:System.BitConverter.ToDouble(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToHalf(System.Byte[],System.Int32) -M:System.BitConverter.ToHalf(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToInt16(System.Byte[],System.Int32) -M:System.BitConverter.ToInt16(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToInt32(System.Byte[],System.Int32) -M:System.BitConverter.ToInt32(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToInt64(System.Byte[],System.Int32) -M:System.BitConverter.ToInt64(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToSingle(System.Byte[],System.Int32) -M:System.BitConverter.ToSingle(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToString(System.Byte[]) -M:System.BitConverter.ToString(System.Byte[],System.Int32) -M:System.BitConverter.ToString(System.Byte[],System.Int32,System.Int32) -M:System.BitConverter.ToUInt16(System.Byte[],System.Int32) -M:System.BitConverter.ToUInt16(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToUInt32(System.Byte[],System.Int32) -M:System.BitConverter.ToUInt32(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.ToUInt64(System.Byte[],System.Int32) -M:System.BitConverter.ToUInt64(System.ReadOnlySpan{System.Byte}) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Boolean) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Char) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Double) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Half) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int16) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int32) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Int64) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.Single) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt16) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt32) -M:System.BitConverter.TryWriteBytes(System.Span{System.Byte},System.UInt64) -M:System.BitConverter.UInt16BitsToHalf(System.UInt16) -M:System.BitConverter.UInt32BitsToSingle(System.UInt32) -M:System.BitConverter.UInt64BitsToDouble(System.UInt64) -M:System.Boolean.CompareTo(System.Boolean) -M:System.Boolean.CompareTo(System.Object) -M:System.Boolean.Equals(System.Boolean) -M:System.Boolean.Equals(System.Object) -M:System.Boolean.GetHashCode -M:System.Boolean.GetTypeCode -M:System.Boolean.Parse(System.ReadOnlySpan{System.Char}) -M:System.Boolean.Parse(System.String) -M:System.Boolean.ToString -M:System.Boolean.ToString(System.IFormatProvider) -M:System.Boolean.TryFormat(System.Span{System.Char},System.Int32@) -M:System.Boolean.TryParse(System.ReadOnlySpan{System.Char},System.Boolean@) -M:System.Boolean.TryParse(System.String,System.Boolean@) -M:System.Buffer.BlockCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32) -M:System.Buffer.ByteLength(System.Array) -M:System.Buffer.GetByte(System.Array,System.Int32) -M:System.Buffer.MemoryCopy(System.Void*,System.Void*,System.Int64,System.Int64) -M:System.Buffer.MemoryCopy(System.Void*,System.Void*,System.UInt64,System.UInt64) -M:System.Buffer.SetByte(System.Array,System.Int32,System.Byte) -M:System.Buffers.ArrayPool`1.#ctor -M:System.Buffers.ArrayPool`1.Create -M:System.Buffers.ArrayPool`1.Create(System.Int32,System.Int32) -M:System.Buffers.ArrayPool`1.get_Shared -M:System.Buffers.ArrayPool`1.Rent(System.Int32) -M:System.Buffers.ArrayPool`1.Return(`0[],System.Boolean) -M:System.Buffers.IMemoryOwner`1.get_Memory -M:System.Buffers.IPinnable.Pin(System.Int32) -M:System.Buffers.IPinnable.Unpin -M:System.Buffers.MemoryHandle.#ctor(System.Void*,System.Runtime.InteropServices.GCHandle,System.Buffers.IPinnable) -M:System.Buffers.MemoryHandle.Dispose -M:System.Buffers.MemoryHandle.get_Pointer -M:System.Buffers.MemoryManager`1.#ctor -M:System.Buffers.MemoryManager`1.CreateMemory(System.Int32) -M:System.Buffers.MemoryManager`1.CreateMemory(System.Int32,System.Int32) -M:System.Buffers.MemoryManager`1.Dispose(System.Boolean) -M:System.Buffers.MemoryManager`1.get_Memory -M:System.Buffers.MemoryManager`1.GetSpan -M:System.Buffers.MemoryManager`1.Pin(System.Int32) -M:System.Buffers.MemoryManager`1.TryGetArray(System.ArraySegment{`0}@) -M:System.Buffers.MemoryManager`1.Unpin -M:System.Buffers.ReadOnlySpanAction`2.#ctor(System.Object,System.IntPtr) -M:System.Buffers.ReadOnlySpanAction`2.BeginInvoke(System.ReadOnlySpan{`0},`1,System.AsyncCallback,System.Object) -M:System.Buffers.ReadOnlySpanAction`2.EndInvoke(System.IAsyncResult) -M:System.Buffers.ReadOnlySpanAction`2.Invoke(System.ReadOnlySpan{`0},`1) -M:System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Byte}) -M:System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Char}) -M:System.Buffers.SearchValues`1.Contains(`0) -M:System.Buffers.SpanAction`2.#ctor(System.Object,System.IntPtr) -M:System.Buffers.SpanAction`2.BeginInvoke(System.Span{`0},`1,System.AsyncCallback,System.Object) -M:System.Buffers.SpanAction`2.EndInvoke(System.IAsyncResult) -M:System.Buffers.SpanAction`2.Invoke(System.Span{`0},`1) -M:System.Buffers.Text.Base64.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) -M:System.Buffers.Text.Base64.DecodeFromUtf8InPlace(System.Span{System.Byte},System.Int32@) -M:System.Buffers.Text.Base64.EncodeToUtf8(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean) -M:System.Buffers.Text.Base64.EncodeToUtf8InPlace(System.Span{System.Byte},System.Int32,System.Int32@) -M:System.Buffers.Text.Base64.GetMaxDecodedFromUtf8Length(System.Int32) -M:System.Buffers.Text.Base64.GetMaxEncodedToUtf8Length(System.Int32) -M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte}) -M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Byte},System.Int32@) -M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char}) -M:System.Buffers.Text.Base64.IsValid(System.ReadOnlySpan{System.Char},System.Int32@) -M:System.Byte.Clamp(System.Byte,System.Byte,System.Byte) -M:System.Byte.CompareTo(System.Byte) -M:System.Byte.CompareTo(System.Object) -M:System.Byte.CreateChecked``1(``0) -M:System.Byte.CreateSaturating``1(``0) -M:System.Byte.CreateTruncating``1(``0) -M:System.Byte.DivRem(System.Byte,System.Byte) -M:System.Byte.Equals(System.Byte) -M:System.Byte.Equals(System.Object) -M:System.Byte.GetHashCode -M:System.Byte.GetTypeCode -M:System.Byte.IsEvenInteger(System.Byte) -M:System.Byte.IsOddInteger(System.Byte) -M:System.Byte.IsPow2(System.Byte) -M:System.Byte.LeadingZeroCount(System.Byte) -M:System.Byte.Log2(System.Byte) -M:System.Byte.Max(System.Byte,System.Byte) -M:System.Byte.Min(System.Byte,System.Byte) -M:System.Byte.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Byte.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Byte.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Byte.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Byte.Parse(System.String) -M:System.Byte.Parse(System.String,System.Globalization.NumberStyles) -M:System.Byte.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Byte.Parse(System.String,System.IFormatProvider) -M:System.Byte.PopCount(System.Byte) -M:System.Byte.RotateLeft(System.Byte,System.Int32) -M:System.Byte.RotateRight(System.Byte,System.Int32) -M:System.Byte.Sign(System.Byte) -M:System.Byte.ToString -M:System.Byte.ToString(System.IFormatProvider) -M:System.Byte.ToString(System.String) -M:System.Byte.ToString(System.String,System.IFormatProvider) -M:System.Byte.TrailingZeroCount(System.Byte) -M:System.Byte.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Byte.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.Byte@) -M:System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) -M:System.Byte.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Byte@) -M:System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.Byte@) -M:System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) -M:System.Byte.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Byte@) -M:System.Byte.TryParse(System.String,System.Byte@) -M:System.Byte.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@) -M:System.Byte.TryParse(System.String,System.IFormatProvider,System.Byte@) -M:System.CannotUnloadAppDomainException.#ctor -M:System.CannotUnloadAppDomainException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.CannotUnloadAppDomainException.#ctor(System.String) -M:System.CannotUnloadAppDomainException.#ctor(System.String,System.Exception) -M:System.Char.CompareTo(System.Char) -M:System.Char.CompareTo(System.Object) -M:System.Char.ConvertFromUtf32(System.Int32) -M:System.Char.ConvertToUtf32(System.Char,System.Char) -M:System.Char.ConvertToUtf32(System.String,System.Int32) -M:System.Char.Equals(System.Char) -M:System.Char.Equals(System.Object) -M:System.Char.GetHashCode -M:System.Char.GetNumericValue(System.Char) -M:System.Char.GetNumericValue(System.String,System.Int32) -M:System.Char.GetTypeCode -M:System.Char.GetUnicodeCategory(System.Char) -M:System.Char.GetUnicodeCategory(System.String,System.Int32) -M:System.Char.IsAscii(System.Char) -M:System.Char.IsAsciiDigit(System.Char) -M:System.Char.IsAsciiHexDigit(System.Char) -M:System.Char.IsAsciiHexDigitLower(System.Char) -M:System.Char.IsAsciiHexDigitUpper(System.Char) -M:System.Char.IsAsciiLetter(System.Char) -M:System.Char.IsAsciiLetterLower(System.Char) -M:System.Char.IsAsciiLetterOrDigit(System.Char) -M:System.Char.IsAsciiLetterUpper(System.Char) -M:System.Char.IsBetween(System.Char,System.Char,System.Char) -M:System.Char.IsControl(System.Char) -M:System.Char.IsControl(System.String,System.Int32) -M:System.Char.IsDigit(System.Char) -M:System.Char.IsDigit(System.String,System.Int32) -M:System.Char.IsHighSurrogate(System.Char) -M:System.Char.IsHighSurrogate(System.String,System.Int32) -M:System.Char.IsLetter(System.Char) -M:System.Char.IsLetter(System.String,System.Int32) -M:System.Char.IsLetterOrDigit(System.Char) -M:System.Char.IsLetterOrDigit(System.String,System.Int32) -M:System.Char.IsLower(System.Char) -M:System.Char.IsLower(System.String,System.Int32) -M:System.Char.IsLowSurrogate(System.Char) -M:System.Char.IsLowSurrogate(System.String,System.Int32) -M:System.Char.IsNumber(System.Char) -M:System.Char.IsNumber(System.String,System.Int32) -M:System.Char.IsPunctuation(System.Char) -M:System.Char.IsPunctuation(System.String,System.Int32) -M:System.Char.IsSeparator(System.Char) -M:System.Char.IsSeparator(System.String,System.Int32) -M:System.Char.IsSurrogate(System.Char) -M:System.Char.IsSurrogate(System.String,System.Int32) -M:System.Char.IsSurrogatePair(System.Char,System.Char) -M:System.Char.IsSurrogatePair(System.String,System.Int32) -M:System.Char.IsSymbol(System.Char) -M:System.Char.IsSymbol(System.String,System.Int32) -M:System.Char.IsUpper(System.Char) -M:System.Char.IsUpper(System.String,System.Int32) -M:System.Char.IsWhiteSpace(System.Char) -M:System.Char.IsWhiteSpace(System.String,System.Int32) -M:System.Char.Parse(System.String) -M:System.Char.ToLower(System.Char) -M:System.Char.ToLower(System.Char,System.Globalization.CultureInfo) -M:System.Char.ToLowerInvariant(System.Char) -M:System.Char.ToString -M:System.Char.ToString(System.Char) -M:System.Char.ToString(System.IFormatProvider) -M:System.Char.ToUpper(System.Char) -M:System.Char.ToUpper(System.Char,System.Globalization.CultureInfo) -M:System.Char.ToUpperInvariant(System.Char) -M:System.Char.TryParse(System.String,System.Char@) -M:System.CharEnumerator.Clone -M:System.CharEnumerator.Dispose -M:System.CharEnumerator.get_Current -M:System.CharEnumerator.MoveNext -M:System.CharEnumerator.Reset -M:System.CLSCompliantAttribute.#ctor(System.Boolean) -M:System.CLSCompliantAttribute.get_IsCompliant -M:System.CodeDom.Compiler.GeneratedCodeAttribute.#ctor(System.String,System.String) -M:System.CodeDom.Compiler.GeneratedCodeAttribute.get_Tool -M:System.CodeDom.Compiler.GeneratedCodeAttribute.get_Version -M:System.CodeDom.Compiler.IndentedTextWriter.#ctor(System.IO.TextWriter) -M:System.CodeDom.Compiler.IndentedTextWriter.#ctor(System.IO.TextWriter,System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.Close -M:System.CodeDom.Compiler.IndentedTextWriter.DisposeAsync -M:System.CodeDom.Compiler.IndentedTextWriter.Flush -M:System.CodeDom.Compiler.IndentedTextWriter.FlushAsync -M:System.CodeDom.Compiler.IndentedTextWriter.FlushAsync(System.Threading.CancellationToken) -M:System.CodeDom.Compiler.IndentedTextWriter.get_Encoding -M:System.CodeDom.Compiler.IndentedTextWriter.get_Indent -M:System.CodeDom.Compiler.IndentedTextWriter.get_InnerWriter -M:System.CodeDom.Compiler.IndentedTextWriter.get_NewLine -M:System.CodeDom.Compiler.IndentedTextWriter.OutputTabs -M:System.CodeDom.Compiler.IndentedTextWriter.OutputTabsAsync -M:System.CodeDom.Compiler.IndentedTextWriter.set_Indent(System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.set_NewLine(System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Boolean) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Char) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Char[]) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Char[],System.Int32,System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Double) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Int64) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Object) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.Single) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String,System.Object) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String,System.Object,System.Object) -M:System.CodeDom.Compiler.IndentedTextWriter.Write(System.String,System.Object[]) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.Char) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.Char[],System.Int32,System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.ReadOnlyMemory{System.Char},System.Threading.CancellationToken) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteAsync(System.Text.StringBuilder,System.Threading.CancellationToken) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Boolean) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Char) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Char[]) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Char[],System.Int32,System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Double) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Int64) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Object) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.Single) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String,System.Object) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String,System.Object,System.Object) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.String,System.Object[]) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLine(System.UInt32) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.Char) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.Char[],System.Int32,System.Int32) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.ReadOnlyMemory{System.Char},System.Threading.CancellationToken) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineAsync(System.Text.StringBuilder,System.Threading.CancellationToken) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineNoTabs(System.String) -M:System.CodeDom.Compiler.IndentedTextWriter.WriteLineNoTabsAsync(System.String) -M:System.Collections.ArrayList.#ctor -M:System.Collections.ArrayList.#ctor(System.Collections.ICollection) -M:System.Collections.ArrayList.#ctor(System.Int32) -M:System.Collections.ArrayList.Adapter(System.Collections.IList) -M:System.Collections.ArrayList.Add(System.Object) -M:System.Collections.ArrayList.AddRange(System.Collections.ICollection) -M:System.Collections.ArrayList.BinarySearch(System.Int32,System.Int32,System.Object,System.Collections.IComparer) -M:System.Collections.ArrayList.BinarySearch(System.Object) -M:System.Collections.ArrayList.BinarySearch(System.Object,System.Collections.IComparer) -M:System.Collections.ArrayList.Clear -M:System.Collections.ArrayList.Clone -M:System.Collections.ArrayList.Contains(System.Object) -M:System.Collections.ArrayList.CopyTo(System.Array) -M:System.Collections.ArrayList.CopyTo(System.Array,System.Int32) -M:System.Collections.ArrayList.CopyTo(System.Int32,System.Array,System.Int32,System.Int32) -M:System.Collections.ArrayList.FixedSize(System.Collections.ArrayList) -M:System.Collections.ArrayList.FixedSize(System.Collections.IList) -M:System.Collections.ArrayList.get_Capacity -M:System.Collections.ArrayList.get_Count -M:System.Collections.ArrayList.get_IsFixedSize -M:System.Collections.ArrayList.get_IsReadOnly -M:System.Collections.ArrayList.get_IsSynchronized -M:System.Collections.ArrayList.get_Item(System.Int32) -M:System.Collections.ArrayList.get_SyncRoot -M:System.Collections.ArrayList.GetEnumerator -M:System.Collections.ArrayList.GetEnumerator(System.Int32,System.Int32) -M:System.Collections.ArrayList.GetRange(System.Int32,System.Int32) -M:System.Collections.ArrayList.IndexOf(System.Object) -M:System.Collections.ArrayList.IndexOf(System.Object,System.Int32) -M:System.Collections.ArrayList.IndexOf(System.Object,System.Int32,System.Int32) -M:System.Collections.ArrayList.Insert(System.Int32,System.Object) -M:System.Collections.ArrayList.InsertRange(System.Int32,System.Collections.ICollection) -M:System.Collections.ArrayList.LastIndexOf(System.Object) -M:System.Collections.ArrayList.LastIndexOf(System.Object,System.Int32) -M:System.Collections.ArrayList.LastIndexOf(System.Object,System.Int32,System.Int32) -M:System.Collections.ArrayList.ReadOnly(System.Collections.ArrayList) -M:System.Collections.ArrayList.ReadOnly(System.Collections.IList) -M:System.Collections.ArrayList.Remove(System.Object) -M:System.Collections.ArrayList.RemoveAt(System.Int32) -M:System.Collections.ArrayList.RemoveRange(System.Int32,System.Int32) -M:System.Collections.ArrayList.Repeat(System.Object,System.Int32) -M:System.Collections.ArrayList.Reverse -M:System.Collections.ArrayList.Reverse(System.Int32,System.Int32) -M:System.Collections.ArrayList.set_Capacity(System.Int32) -M:System.Collections.ArrayList.set_Item(System.Int32,System.Object) -M:System.Collections.ArrayList.SetRange(System.Int32,System.Collections.ICollection) -M:System.Collections.ArrayList.Sort -M:System.Collections.ArrayList.Sort(System.Collections.IComparer) -M:System.Collections.ArrayList.Sort(System.Int32,System.Int32,System.Collections.IComparer) -M:System.Collections.ArrayList.Synchronized(System.Collections.ArrayList) -M:System.Collections.ArrayList.Synchronized(System.Collections.IList) -M:System.Collections.ArrayList.ToArray -M:System.Collections.ArrayList.ToArray(System.Type) -M:System.Collections.ArrayList.TrimToSize -M:System.Collections.Comparer.#ctor(System.Globalization.CultureInfo) -M:System.Collections.Comparer.Compare(System.Object,System.Object) -M:System.Collections.Comparer.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.DictionaryEntry.#ctor(System.Object,System.Object) -M:System.Collections.DictionaryEntry.Deconstruct(System.Object@,System.Object@) -M:System.Collections.DictionaryEntry.get_Key -M:System.Collections.DictionaryEntry.get_Value -M:System.Collections.DictionaryEntry.set_Key(System.Object) -M:System.Collections.DictionaryEntry.set_Value(System.Object) -M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken) -M:System.Collections.Generic.IAsyncEnumerator`1.get_Current -M:System.Collections.Generic.IAsyncEnumerator`1.MoveNextAsync -M:System.Collections.Generic.ICollection`1.Add(`0) -M:System.Collections.Generic.ICollection`1.Clear -M:System.Collections.Generic.ICollection`1.Contains(`0) -M:System.Collections.Generic.ICollection`1.CopyTo(`0[],System.Int32) -M:System.Collections.Generic.ICollection`1.get_Count -M:System.Collections.Generic.ICollection`1.get_IsReadOnly -M:System.Collections.Generic.ICollection`1.Remove(`0) -M:System.Collections.Generic.IComparer`1.Compare(`0,`0) -M:System.Collections.Generic.IDictionary`2.Add(`0,`1) -M:System.Collections.Generic.IDictionary`2.ContainsKey(`0) -M:System.Collections.Generic.IDictionary`2.get_Item(`0) -M:System.Collections.Generic.IDictionary`2.get_Keys -M:System.Collections.Generic.IDictionary`2.get_Values -M:System.Collections.Generic.IDictionary`2.Remove(`0) -M:System.Collections.Generic.IDictionary`2.set_Item(`0,`1) -M:System.Collections.Generic.IDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Generic.IEnumerable`1.GetEnumerator -M:System.Collections.Generic.IEnumerator`1.get_Current -M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0) -M:System.Collections.Generic.IEqualityComparer`1.GetHashCode(`0) -M:System.Collections.Generic.IList`1.get_Item(System.Int32) -M:System.Collections.Generic.IList`1.IndexOf(`0) -M:System.Collections.Generic.IList`1.Insert(System.Int32,`0) -M:System.Collections.Generic.IList`1.RemoveAt(System.Int32) -M:System.Collections.Generic.IList`1.set_Item(System.Int32,`0) -M:System.Collections.Generic.IReadOnlyCollection`1.get_Count -M:System.Collections.Generic.IReadOnlyDictionary`2.ContainsKey(`0) -M:System.Collections.Generic.IReadOnlyDictionary`2.get_Item(`0) -M:System.Collections.Generic.IReadOnlyDictionary`2.get_Keys -M:System.Collections.Generic.IReadOnlyDictionary`2.get_Values -M:System.Collections.Generic.IReadOnlyDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.Generic.IReadOnlyList`1.get_Item(System.Int32) -M:System.Collections.Generic.IReadOnlySet`1.Contains(`0) -M:System.Collections.Generic.IReadOnlySet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.IReadOnlySet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.IReadOnlySet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.IReadOnlySet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.IReadOnlySet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.IReadOnlySet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.Add(`0) -M:System.Collections.Generic.ISet`1.ExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.IntersectWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.IsProperSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.IsProperSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.IsSubsetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.IsSupersetOf(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.Overlaps(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.SetEquals(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.SymmetricExceptWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.ISet`1.UnionWith(System.Collections.Generic.IEnumerable{`0}) -M:System.Collections.Generic.KeyNotFoundException.#ctor -M:System.Collections.Generic.KeyNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Generic.KeyNotFoundException.#ctor(System.String) -M:System.Collections.Generic.KeyNotFoundException.#ctor(System.String,System.Exception) -M:System.Collections.Generic.KeyValuePair.Create``2(``0,``1) -M:System.Collections.Generic.KeyValuePair`2.#ctor(`0,`1) -M:System.Collections.Generic.KeyValuePair`2.Deconstruct(`0@,`1@) -M:System.Collections.Generic.KeyValuePair`2.get_Key -M:System.Collections.Generic.KeyValuePair`2.get_Value -M:System.Collections.Generic.KeyValuePair`2.ToString -M:System.Collections.Hashtable.#ctor -M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary) -M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IEqualityComparer) -M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IHashCodeProvider,System.Collections.IComparer) -M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single) -M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single,System.Collections.IEqualityComparer) -M:System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Single,System.Collections.IHashCodeProvider,System.Collections.IComparer) -M:System.Collections.Hashtable.#ctor(System.Collections.IEqualityComparer) -M:System.Collections.Hashtable.#ctor(System.Collections.IHashCodeProvider,System.Collections.IComparer) -M:System.Collections.Hashtable.#ctor(System.Int32) -M:System.Collections.Hashtable.#ctor(System.Int32,System.Collections.IEqualityComparer) -M:System.Collections.Hashtable.#ctor(System.Int32,System.Collections.IHashCodeProvider,System.Collections.IComparer) -M:System.Collections.Hashtable.#ctor(System.Int32,System.Single) -M:System.Collections.Hashtable.#ctor(System.Int32,System.Single,System.Collections.IEqualityComparer) -M:System.Collections.Hashtable.#ctor(System.Int32,System.Single,System.Collections.IHashCodeProvider,System.Collections.IComparer) -M:System.Collections.Hashtable.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Hashtable.Add(System.Object,System.Object) -M:System.Collections.Hashtable.Clear -M:System.Collections.Hashtable.Clone -M:System.Collections.Hashtable.Contains(System.Object) -M:System.Collections.Hashtable.ContainsKey(System.Object) -M:System.Collections.Hashtable.ContainsValue(System.Object) -M:System.Collections.Hashtable.CopyTo(System.Array,System.Int32) -M:System.Collections.Hashtable.get_comparer -M:System.Collections.Hashtable.get_Count -M:System.Collections.Hashtable.get_EqualityComparer -M:System.Collections.Hashtable.get_hcp -M:System.Collections.Hashtable.get_IsFixedSize -M:System.Collections.Hashtable.get_IsReadOnly -M:System.Collections.Hashtable.get_IsSynchronized -M:System.Collections.Hashtable.get_Item(System.Object) -M:System.Collections.Hashtable.get_Keys -M:System.Collections.Hashtable.get_SyncRoot -M:System.Collections.Hashtable.get_Values -M:System.Collections.Hashtable.GetEnumerator -M:System.Collections.Hashtable.GetHash(System.Object) -M:System.Collections.Hashtable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Collections.Hashtable.KeyEquals(System.Object,System.Object) -M:System.Collections.Hashtable.OnDeserialization(System.Object) -M:System.Collections.Hashtable.Remove(System.Object) -M:System.Collections.Hashtable.set_comparer(System.Collections.IComparer) -M:System.Collections.Hashtable.set_hcp(System.Collections.IHashCodeProvider) -M:System.Collections.Hashtable.set_Item(System.Object,System.Object) -M:System.Collections.Hashtable.Synchronized(System.Collections.Hashtable) -M:System.Collections.ICollection.CopyTo(System.Array,System.Int32) -M:System.Collections.ICollection.get_Count -M:System.Collections.ICollection.get_IsSynchronized -M:System.Collections.ICollection.get_SyncRoot -M:System.Collections.IComparer.Compare(System.Object,System.Object) -M:System.Collections.IDictionary.Add(System.Object,System.Object) -M:System.Collections.IDictionary.Clear -M:System.Collections.IDictionary.Contains(System.Object) -M:System.Collections.IDictionary.get_IsFixedSize -M:System.Collections.IDictionary.get_IsReadOnly -M:System.Collections.IDictionary.get_Item(System.Object) -M:System.Collections.IDictionary.get_Keys -M:System.Collections.IDictionary.get_Values -M:System.Collections.IDictionary.GetEnumerator -M:System.Collections.IDictionary.Remove(System.Object) -M:System.Collections.IDictionary.set_Item(System.Object,System.Object) -M:System.Collections.IDictionaryEnumerator.get_Entry -M:System.Collections.IDictionaryEnumerator.get_Key -M:System.Collections.IDictionaryEnumerator.get_Value -M:System.Collections.IEnumerable.GetEnumerator -M:System.Collections.IEnumerator.get_Current -M:System.Collections.IEnumerator.MoveNext -M:System.Collections.IEnumerator.Reset -M:System.Collections.IEqualityComparer.Equals(System.Object,System.Object) -M:System.Collections.IEqualityComparer.GetHashCode(System.Object) -M:System.Collections.IHashCodeProvider.GetHashCode(System.Object) -M:System.Collections.IList.Add(System.Object) -M:System.Collections.IList.Clear -M:System.Collections.IList.Contains(System.Object) -M:System.Collections.IList.get_IsFixedSize -M:System.Collections.IList.get_IsReadOnly -M:System.Collections.IList.get_Item(System.Int32) -M:System.Collections.IList.IndexOf(System.Object) -M:System.Collections.IList.Insert(System.Int32,System.Object) -M:System.Collections.IList.Remove(System.Object) -M:System.Collections.IList.RemoveAt(System.Int32) -M:System.Collections.IList.set_Item(System.Int32,System.Object) -M:System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer) -M:System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer) -M:System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer) -M:System.Collections.ObjectModel.Collection`1.#ctor -M:System.Collections.ObjectModel.Collection`1.#ctor(System.Collections.Generic.IList{`0}) -M:System.Collections.ObjectModel.Collection`1.Add(`0) -M:System.Collections.ObjectModel.Collection`1.Clear -M:System.Collections.ObjectModel.Collection`1.ClearItems -M:System.Collections.ObjectModel.Collection`1.Contains(`0) -M:System.Collections.ObjectModel.Collection`1.CopyTo(`0[],System.Int32) -M:System.Collections.ObjectModel.Collection`1.get_Count -M:System.Collections.ObjectModel.Collection`1.get_Item(System.Int32) -M:System.Collections.ObjectModel.Collection`1.get_Items -M:System.Collections.ObjectModel.Collection`1.GetEnumerator -M:System.Collections.ObjectModel.Collection`1.IndexOf(`0) -M:System.Collections.ObjectModel.Collection`1.Insert(System.Int32,`0) -M:System.Collections.ObjectModel.Collection`1.InsertItem(System.Int32,`0) -M:System.Collections.ObjectModel.Collection`1.Remove(`0) -M:System.Collections.ObjectModel.Collection`1.RemoveAt(System.Int32) -M:System.Collections.ObjectModel.Collection`1.RemoveItem(System.Int32) -M:System.Collections.ObjectModel.Collection`1.set_Item(System.Int32,`0) -M:System.Collections.ObjectModel.Collection`1.SetItem(System.Int32,`0) -M:System.Collections.ObjectModel.ReadOnlyCollection`1.#ctor(System.Collections.Generic.IList{`0}) -M:System.Collections.ObjectModel.ReadOnlyCollection`1.Contains(`0) -M:System.Collections.ObjectModel.ReadOnlyCollection`1.CopyTo(`0[],System.Int32) -M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Count -M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Empty -M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Item(System.Int32) -M:System.Collections.ObjectModel.ReadOnlyCollection`1.get_Items -M:System.Collections.ObjectModel.ReadOnlyCollection`1.GetEnumerator -M:System.Collections.ObjectModel.ReadOnlyCollection`1.IndexOf(`0) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1}) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ContainsKey(`0) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Count -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Dictionary -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Empty -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Item(`0) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Keys -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.get_Values -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.GetEnumerator -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.Contains(`0) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.CopyTo(`0[],System.Int32) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.get_Count -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection.GetEnumerator -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.TryGetValue(`0,`1@) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.CopyTo(`1[],System.Int32) -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.get_Count -M:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection.GetEnumerator -M:System.Comparison`1.#ctor(System.Object,System.IntPtr) -M:System.Comparison`1.BeginInvoke(`0,`0,System.AsyncCallback,System.Object) -M:System.Comparison`1.EndInvoke(System.IAsyncResult) -M:System.Comparison`1.Invoke(`0,`0) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Boolean) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Byte) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Char) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Double) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Int16) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Int32) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Int64) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Object) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.SByte) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Single) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.String) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.Type,System.String) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt16) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt32) -M:System.ComponentModel.DefaultValueAttribute.#ctor(System.UInt64) -M:System.ComponentModel.DefaultValueAttribute.Equals(System.Object) -M:System.ComponentModel.DefaultValueAttribute.get_Value -M:System.ComponentModel.DefaultValueAttribute.GetHashCode -M:System.ComponentModel.DefaultValueAttribute.SetValue(System.Object) -M:System.ComponentModel.EditorBrowsableAttribute.#ctor -M:System.ComponentModel.EditorBrowsableAttribute.#ctor(System.ComponentModel.EditorBrowsableState) -M:System.ComponentModel.EditorBrowsableAttribute.Equals(System.Object) -M:System.ComponentModel.EditorBrowsableAttribute.get_State -M:System.ComponentModel.EditorBrowsableAttribute.GetHashCode -M:System.ContextBoundObject.#ctor -M:System.ContextMarshalException.#ctor -M:System.ContextMarshalException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ContextMarshalException.#ctor(System.String) -M:System.ContextMarshalException.#ctor(System.String,System.Exception) -M:System.ContextStaticAttribute.#ctor -M:System.Convert.ChangeType(System.Object,System.Type) -M:System.Convert.ChangeType(System.Object,System.Type,System.IFormatProvider) -M:System.Convert.ChangeType(System.Object,System.TypeCode) -M:System.Convert.ChangeType(System.Object,System.TypeCode,System.IFormatProvider) -M:System.Convert.FromBase64CharArray(System.Char[],System.Int32,System.Int32) -M:System.Convert.FromBase64String(System.String) -M:System.Convert.FromHexString(System.ReadOnlySpan{System.Char}) -M:System.Convert.FromHexString(System.String) -M:System.Convert.GetTypeCode(System.Object) -M:System.Convert.IsDBNull(System.Object) -M:System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) -M:System.Convert.ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Base64FormattingOptions) -M:System.Convert.ToBase64String(System.Byte[]) -M:System.Convert.ToBase64String(System.Byte[],System.Base64FormattingOptions) -M:System.Convert.ToBase64String(System.Byte[],System.Int32,System.Int32) -M:System.Convert.ToBase64String(System.Byte[],System.Int32,System.Int32,System.Base64FormattingOptions) -M:System.Convert.ToBase64String(System.ReadOnlySpan{System.Byte},System.Base64FormattingOptions) -M:System.Convert.ToBoolean(System.Boolean) -M:System.Convert.ToBoolean(System.Byte) -M:System.Convert.ToBoolean(System.Char) -M:System.Convert.ToBoolean(System.DateTime) -M:System.Convert.ToBoolean(System.Decimal) -M:System.Convert.ToBoolean(System.Double) -M:System.Convert.ToBoolean(System.Int16) -M:System.Convert.ToBoolean(System.Int32) -M:System.Convert.ToBoolean(System.Int64) -M:System.Convert.ToBoolean(System.Object) -M:System.Convert.ToBoolean(System.Object,System.IFormatProvider) -M:System.Convert.ToBoolean(System.SByte) -M:System.Convert.ToBoolean(System.Single) -M:System.Convert.ToBoolean(System.String) -M:System.Convert.ToBoolean(System.String,System.IFormatProvider) -M:System.Convert.ToBoolean(System.UInt16) -M:System.Convert.ToBoolean(System.UInt32) -M:System.Convert.ToBoolean(System.UInt64) -M:System.Convert.ToByte(System.Boolean) -M:System.Convert.ToByte(System.Byte) -M:System.Convert.ToByte(System.Char) -M:System.Convert.ToByte(System.DateTime) -M:System.Convert.ToByte(System.Decimal) -M:System.Convert.ToByte(System.Double) -M:System.Convert.ToByte(System.Int16) -M:System.Convert.ToByte(System.Int32) -M:System.Convert.ToByte(System.Int64) -M:System.Convert.ToByte(System.Object) -M:System.Convert.ToByte(System.Object,System.IFormatProvider) -M:System.Convert.ToByte(System.SByte) -M:System.Convert.ToByte(System.Single) -M:System.Convert.ToByte(System.String) -M:System.Convert.ToByte(System.String,System.IFormatProvider) -M:System.Convert.ToByte(System.String,System.Int32) -M:System.Convert.ToByte(System.UInt16) -M:System.Convert.ToByte(System.UInt32) -M:System.Convert.ToByte(System.UInt64) -M:System.Convert.ToChar(System.Boolean) -M:System.Convert.ToChar(System.Byte) -M:System.Convert.ToChar(System.Char) -M:System.Convert.ToChar(System.DateTime) -M:System.Convert.ToChar(System.Decimal) -M:System.Convert.ToChar(System.Double) -M:System.Convert.ToChar(System.Int16) -M:System.Convert.ToChar(System.Int32) -M:System.Convert.ToChar(System.Int64) -M:System.Convert.ToChar(System.Object) -M:System.Convert.ToChar(System.Object,System.IFormatProvider) -M:System.Convert.ToChar(System.SByte) -M:System.Convert.ToChar(System.Single) -M:System.Convert.ToChar(System.String) -M:System.Convert.ToChar(System.String,System.IFormatProvider) -M:System.Convert.ToChar(System.UInt16) -M:System.Convert.ToChar(System.UInt32) -M:System.Convert.ToChar(System.UInt64) -M:System.Convert.ToDateTime(System.Boolean) -M:System.Convert.ToDateTime(System.Byte) -M:System.Convert.ToDateTime(System.Char) -M:System.Convert.ToDateTime(System.DateTime) -M:System.Convert.ToDateTime(System.Decimal) -M:System.Convert.ToDateTime(System.Double) -M:System.Convert.ToDateTime(System.Int16) -M:System.Convert.ToDateTime(System.Int32) -M:System.Convert.ToDateTime(System.Int64) -M:System.Convert.ToDateTime(System.Object) -M:System.Convert.ToDateTime(System.Object,System.IFormatProvider) -M:System.Convert.ToDateTime(System.SByte) -M:System.Convert.ToDateTime(System.Single) -M:System.Convert.ToDateTime(System.String) -M:System.Convert.ToDateTime(System.String,System.IFormatProvider) -M:System.Convert.ToDateTime(System.UInt16) -M:System.Convert.ToDateTime(System.UInt32) -M:System.Convert.ToDateTime(System.UInt64) -M:System.Convert.ToDecimal(System.Boolean) -M:System.Convert.ToDecimal(System.Byte) -M:System.Convert.ToDecimal(System.Char) -M:System.Convert.ToDecimal(System.DateTime) -M:System.Convert.ToDecimal(System.Decimal) -M:System.Convert.ToDecimal(System.Double) -M:System.Convert.ToDecimal(System.Int16) -M:System.Convert.ToDecimal(System.Int32) -M:System.Convert.ToDecimal(System.Int64) -M:System.Convert.ToDecimal(System.Object) -M:System.Convert.ToDecimal(System.Object,System.IFormatProvider) -M:System.Convert.ToDecimal(System.SByte) -M:System.Convert.ToDecimal(System.Single) -M:System.Convert.ToDecimal(System.String) -M:System.Convert.ToDecimal(System.String,System.IFormatProvider) -M:System.Convert.ToDecimal(System.UInt16) -M:System.Convert.ToDecimal(System.UInt32) -M:System.Convert.ToDecimal(System.UInt64) -M:System.Convert.ToDouble(System.Boolean) -M:System.Convert.ToDouble(System.Byte) -M:System.Convert.ToDouble(System.Char) -M:System.Convert.ToDouble(System.DateTime) -M:System.Convert.ToDouble(System.Decimal) -M:System.Convert.ToDouble(System.Double) -M:System.Convert.ToDouble(System.Int16) -M:System.Convert.ToDouble(System.Int32) -M:System.Convert.ToDouble(System.Int64) -M:System.Convert.ToDouble(System.Object) -M:System.Convert.ToDouble(System.Object,System.IFormatProvider) -M:System.Convert.ToDouble(System.SByte) -M:System.Convert.ToDouble(System.Single) -M:System.Convert.ToDouble(System.String) -M:System.Convert.ToDouble(System.String,System.IFormatProvider) -M:System.Convert.ToDouble(System.UInt16) -M:System.Convert.ToDouble(System.UInt32) -M:System.Convert.ToDouble(System.UInt64) -M:System.Convert.ToHexString(System.Byte[]) -M:System.Convert.ToHexString(System.Byte[],System.Int32,System.Int32) -M:System.Convert.ToHexString(System.ReadOnlySpan{System.Byte}) -M:System.Convert.ToInt16(System.Boolean) -M:System.Convert.ToInt16(System.Byte) -M:System.Convert.ToInt16(System.Char) -M:System.Convert.ToInt16(System.DateTime) -M:System.Convert.ToInt16(System.Decimal) -M:System.Convert.ToInt16(System.Double) -M:System.Convert.ToInt16(System.Int16) -M:System.Convert.ToInt16(System.Int32) -M:System.Convert.ToInt16(System.Int64) -M:System.Convert.ToInt16(System.Object) -M:System.Convert.ToInt16(System.Object,System.IFormatProvider) -M:System.Convert.ToInt16(System.SByte) -M:System.Convert.ToInt16(System.Single) -M:System.Convert.ToInt16(System.String) -M:System.Convert.ToInt16(System.String,System.IFormatProvider) -M:System.Convert.ToInt16(System.String,System.Int32) -M:System.Convert.ToInt16(System.UInt16) -M:System.Convert.ToInt16(System.UInt32) -M:System.Convert.ToInt16(System.UInt64) -M:System.Convert.ToInt32(System.Boolean) -M:System.Convert.ToInt32(System.Byte) -M:System.Convert.ToInt32(System.Char) -M:System.Convert.ToInt32(System.DateTime) -M:System.Convert.ToInt32(System.Decimal) -M:System.Convert.ToInt32(System.Double) -M:System.Convert.ToInt32(System.Int16) -M:System.Convert.ToInt32(System.Int32) -M:System.Convert.ToInt32(System.Int64) -M:System.Convert.ToInt32(System.Object) -M:System.Convert.ToInt32(System.Object,System.IFormatProvider) -M:System.Convert.ToInt32(System.SByte) -M:System.Convert.ToInt32(System.Single) -M:System.Convert.ToInt32(System.String) -M:System.Convert.ToInt32(System.String,System.IFormatProvider) -M:System.Convert.ToInt32(System.String,System.Int32) -M:System.Convert.ToInt32(System.UInt16) -M:System.Convert.ToInt32(System.UInt32) -M:System.Convert.ToInt32(System.UInt64) -M:System.Convert.ToInt64(System.Boolean) -M:System.Convert.ToInt64(System.Byte) -M:System.Convert.ToInt64(System.Char) -M:System.Convert.ToInt64(System.DateTime) -M:System.Convert.ToInt64(System.Decimal) -M:System.Convert.ToInt64(System.Double) -M:System.Convert.ToInt64(System.Int16) -M:System.Convert.ToInt64(System.Int32) -M:System.Convert.ToInt64(System.Int64) -M:System.Convert.ToInt64(System.Object) -M:System.Convert.ToInt64(System.Object,System.IFormatProvider) -M:System.Convert.ToInt64(System.SByte) -M:System.Convert.ToInt64(System.Single) -M:System.Convert.ToInt64(System.String) -M:System.Convert.ToInt64(System.String,System.IFormatProvider) -M:System.Convert.ToInt64(System.String,System.Int32) -M:System.Convert.ToInt64(System.UInt16) -M:System.Convert.ToInt64(System.UInt32) -M:System.Convert.ToInt64(System.UInt64) -M:System.Convert.ToSByte(System.Boolean) -M:System.Convert.ToSByte(System.Byte) -M:System.Convert.ToSByte(System.Char) -M:System.Convert.ToSByte(System.DateTime) -M:System.Convert.ToSByte(System.Decimal) -M:System.Convert.ToSByte(System.Double) -M:System.Convert.ToSByte(System.Int16) -M:System.Convert.ToSByte(System.Int32) -M:System.Convert.ToSByte(System.Int64) -M:System.Convert.ToSByte(System.Object) -M:System.Convert.ToSByte(System.Object,System.IFormatProvider) -M:System.Convert.ToSByte(System.SByte) -M:System.Convert.ToSByte(System.Single) -M:System.Convert.ToSByte(System.String) -M:System.Convert.ToSByte(System.String,System.IFormatProvider) -M:System.Convert.ToSByte(System.String,System.Int32) -M:System.Convert.ToSByte(System.UInt16) -M:System.Convert.ToSByte(System.UInt32) -M:System.Convert.ToSByte(System.UInt64) -M:System.Convert.ToSingle(System.Boolean) -M:System.Convert.ToSingle(System.Byte) -M:System.Convert.ToSingle(System.Char) -M:System.Convert.ToSingle(System.DateTime) -M:System.Convert.ToSingle(System.Decimal) -M:System.Convert.ToSingle(System.Double) -M:System.Convert.ToSingle(System.Int16) -M:System.Convert.ToSingle(System.Int32) -M:System.Convert.ToSingle(System.Int64) -M:System.Convert.ToSingle(System.Object) -M:System.Convert.ToSingle(System.Object,System.IFormatProvider) -M:System.Convert.ToSingle(System.SByte) -M:System.Convert.ToSingle(System.Single) -M:System.Convert.ToSingle(System.String) -M:System.Convert.ToSingle(System.String,System.IFormatProvider) -M:System.Convert.ToSingle(System.UInt16) -M:System.Convert.ToSingle(System.UInt32) -M:System.Convert.ToSingle(System.UInt64) -M:System.Convert.ToString(System.Boolean) -M:System.Convert.ToString(System.Boolean,System.IFormatProvider) -M:System.Convert.ToString(System.Byte) -M:System.Convert.ToString(System.Byte,System.IFormatProvider) -M:System.Convert.ToString(System.Byte,System.Int32) -M:System.Convert.ToString(System.Char) -M:System.Convert.ToString(System.Char,System.IFormatProvider) -M:System.Convert.ToString(System.DateTime) -M:System.Convert.ToString(System.DateTime,System.IFormatProvider) -M:System.Convert.ToString(System.Decimal) -M:System.Convert.ToString(System.Decimal,System.IFormatProvider) -M:System.Convert.ToString(System.Double) -M:System.Convert.ToString(System.Double,System.IFormatProvider) -M:System.Convert.ToString(System.Int16) -M:System.Convert.ToString(System.Int16,System.IFormatProvider) -M:System.Convert.ToString(System.Int16,System.Int32) -M:System.Convert.ToString(System.Int32) -M:System.Convert.ToString(System.Int32,System.IFormatProvider) -M:System.Convert.ToString(System.Int32,System.Int32) -M:System.Convert.ToString(System.Int64) -M:System.Convert.ToString(System.Int64,System.IFormatProvider) -M:System.Convert.ToString(System.Int64,System.Int32) -M:System.Convert.ToString(System.Object) -M:System.Convert.ToString(System.Object,System.IFormatProvider) -M:System.Convert.ToString(System.SByte) -M:System.Convert.ToString(System.SByte,System.IFormatProvider) -M:System.Convert.ToString(System.Single) -M:System.Convert.ToString(System.Single,System.IFormatProvider) -M:System.Convert.ToString(System.String) -M:System.Convert.ToString(System.String,System.IFormatProvider) -M:System.Convert.ToString(System.UInt16) -M:System.Convert.ToString(System.UInt16,System.IFormatProvider) -M:System.Convert.ToString(System.UInt32) -M:System.Convert.ToString(System.UInt32,System.IFormatProvider) -M:System.Convert.ToString(System.UInt64) -M:System.Convert.ToString(System.UInt64,System.IFormatProvider) -M:System.Convert.ToUInt16(System.Boolean) -M:System.Convert.ToUInt16(System.Byte) -M:System.Convert.ToUInt16(System.Char) -M:System.Convert.ToUInt16(System.DateTime) -M:System.Convert.ToUInt16(System.Decimal) -M:System.Convert.ToUInt16(System.Double) -M:System.Convert.ToUInt16(System.Int16) -M:System.Convert.ToUInt16(System.Int32) -M:System.Convert.ToUInt16(System.Int64) -M:System.Convert.ToUInt16(System.Object) -M:System.Convert.ToUInt16(System.Object,System.IFormatProvider) -M:System.Convert.ToUInt16(System.SByte) -M:System.Convert.ToUInt16(System.Single) -M:System.Convert.ToUInt16(System.String) -M:System.Convert.ToUInt16(System.String,System.IFormatProvider) -M:System.Convert.ToUInt16(System.String,System.Int32) -M:System.Convert.ToUInt16(System.UInt16) -M:System.Convert.ToUInt16(System.UInt32) -M:System.Convert.ToUInt16(System.UInt64) -M:System.Convert.ToUInt32(System.Boolean) -M:System.Convert.ToUInt32(System.Byte) -M:System.Convert.ToUInt32(System.Char) -M:System.Convert.ToUInt32(System.DateTime) -M:System.Convert.ToUInt32(System.Decimal) -M:System.Convert.ToUInt32(System.Double) -M:System.Convert.ToUInt32(System.Int16) -M:System.Convert.ToUInt32(System.Int32) -M:System.Convert.ToUInt32(System.Int64) -M:System.Convert.ToUInt32(System.Object) -M:System.Convert.ToUInt32(System.Object,System.IFormatProvider) -M:System.Convert.ToUInt32(System.SByte) -M:System.Convert.ToUInt32(System.Single) -M:System.Convert.ToUInt32(System.String) -M:System.Convert.ToUInt32(System.String,System.IFormatProvider) -M:System.Convert.ToUInt32(System.String,System.Int32) -M:System.Convert.ToUInt32(System.UInt16) -M:System.Convert.ToUInt32(System.UInt32) -M:System.Convert.ToUInt32(System.UInt64) -M:System.Convert.ToUInt64(System.Boolean) -M:System.Convert.ToUInt64(System.Byte) -M:System.Convert.ToUInt64(System.Char) -M:System.Convert.ToUInt64(System.DateTime) -M:System.Convert.ToUInt64(System.Decimal) -M:System.Convert.ToUInt64(System.Double) -M:System.Convert.ToUInt64(System.Int16) -M:System.Convert.ToUInt64(System.Int32) -M:System.Convert.ToUInt64(System.Int64) -M:System.Convert.ToUInt64(System.Object) -M:System.Convert.ToUInt64(System.Object,System.IFormatProvider) -M:System.Convert.ToUInt64(System.SByte) -M:System.Convert.ToUInt64(System.Single) -M:System.Convert.ToUInt64(System.String) -M:System.Convert.ToUInt64(System.String,System.IFormatProvider) -M:System.Convert.ToUInt64(System.String,System.Int32) -M:System.Convert.ToUInt64(System.UInt16) -M:System.Convert.ToUInt64(System.UInt32) -M:System.Convert.ToUInt64(System.UInt64) -M:System.Convert.TryFromBase64Chars(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) -M:System.Convert.TryFromBase64String(System.String,System.Span{System.Byte},System.Int32@) -M:System.Convert.TryToBase64Chars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Base64FormattingOptions) -M:System.Converter`2.#ctor(System.Object,System.IntPtr) -M:System.Converter`2.BeginInvoke(`0,System.AsyncCallback,System.Object) -M:System.Converter`2.EndInvoke(System.IAsyncResult) -M:System.Converter`2.Invoke(`0) -M:System.DateOnly.#ctor(System.Int32,System.Int32,System.Int32) -M:System.DateOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) -M:System.DateOnly.AddDays(System.Int32) -M:System.DateOnly.AddMonths(System.Int32) -M:System.DateOnly.AddYears(System.Int32) -M:System.DateOnly.CompareTo(System.DateOnly) -M:System.DateOnly.CompareTo(System.Object) -M:System.DateOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@) -M:System.DateOnly.Equals(System.DateOnly) -M:System.DateOnly.Equals(System.Object) -M:System.DateOnly.FromDateTime(System.DateTime) -M:System.DateOnly.FromDayNumber(System.Int32) -M:System.DateOnly.get_Day -M:System.DateOnly.get_DayNumber -M:System.DateOnly.get_DayOfWeek -M:System.DateOnly.get_DayOfYear -M:System.DateOnly.get_MaxValue -M:System.DateOnly.get_MinValue -M:System.DateOnly.get_Month -M:System.DateOnly.get_Year -M:System.DateOnly.GetHashCode -M:System.DateOnly.op_Equality(System.DateOnly,System.DateOnly) -M:System.DateOnly.op_GreaterThan(System.DateOnly,System.DateOnly) -M:System.DateOnly.op_GreaterThanOrEqual(System.DateOnly,System.DateOnly) -M:System.DateOnly.op_Inequality(System.DateOnly,System.DateOnly) -M:System.DateOnly.op_LessThan(System.DateOnly,System.DateOnly) -M:System.DateOnly.op_LessThanOrEqual(System.DateOnly,System.DateOnly) -M:System.DateOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateOnly.Parse(System.String) -M:System.DateOnly.Parse(System.String,System.IFormatProvider) -M:System.DateOnly.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[]) -M:System.DateOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateOnly.ParseExact(System.String,System.String) -M:System.DateOnly.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateOnly.ParseExact(System.String,System.String[]) -M:System.DateOnly.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateOnly.ToDateTime(System.TimeOnly) -M:System.DateOnly.ToDateTime(System.TimeOnly,System.DateTimeKind) -M:System.DateOnly.ToLongDateString -M:System.DateOnly.ToShortDateString -M:System.DateOnly.ToString -M:System.DateOnly.ToString(System.IFormatProvider) -M:System.DateOnly.ToString(System.String) -M:System.DateOnly.ToString(System.String,System.IFormatProvider) -M:System.DateOnly.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateOnly.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.DateOnly@) -M:System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateOnly@) -M:System.DateOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) -M:System.DateOnly.TryParse(System.String,System.DateOnly@) -M:System.DateOnly.TryParse(System.String,System.IFormatProvider,System.DateOnly@) -M:System.DateOnly.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) -M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.DateOnly@) -M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) -M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.DateOnly@) -M:System.DateOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) -M:System.DateOnly.TryParseExact(System.String,System.String,System.DateOnly@) -M:System.DateOnly.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) -M:System.DateOnly.TryParseExact(System.String,System.String[],System.DateOnly@) -M:System.DateOnly.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateOnly@) -M:System.DateTime.#ctor(System.DateOnly,System.TimeOnly) -M:System.DateTime.#ctor(System.DateOnly,System.TimeOnly,System.DateTimeKind) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar) -M:System.DateTime.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind) -M:System.DateTime.#ctor(System.Int64) -M:System.DateTime.#ctor(System.Int64,System.DateTimeKind) -M:System.DateTime.Add(System.TimeSpan) -M:System.DateTime.AddDays(System.Double) -M:System.DateTime.AddHours(System.Double) -M:System.DateTime.AddMicroseconds(System.Double) -M:System.DateTime.AddMilliseconds(System.Double) -M:System.DateTime.AddMinutes(System.Double) -M:System.DateTime.AddMonths(System.Int32) -M:System.DateTime.AddSeconds(System.Double) -M:System.DateTime.AddTicks(System.Int64) -M:System.DateTime.AddYears(System.Int32) -M:System.DateTime.Compare(System.DateTime,System.DateTime) -M:System.DateTime.CompareTo(System.DateTime) -M:System.DateTime.CompareTo(System.Object) -M:System.DateTime.DaysInMonth(System.Int32,System.Int32) -M:System.DateTime.Deconstruct(System.DateOnly@,System.TimeOnly@) -M:System.DateTime.Deconstruct(System.Int32@,System.Int32@,System.Int32@) -M:System.DateTime.Equals(System.DateTime) -M:System.DateTime.Equals(System.DateTime,System.DateTime) -M:System.DateTime.Equals(System.Object) -M:System.DateTime.FromBinary(System.Int64) -M:System.DateTime.FromFileTime(System.Int64) -M:System.DateTime.FromFileTimeUtc(System.Int64) -M:System.DateTime.FromOADate(System.Double) -M:System.DateTime.get_Date -M:System.DateTime.get_Day -M:System.DateTime.get_DayOfWeek -M:System.DateTime.get_DayOfYear -M:System.DateTime.get_Hour -M:System.DateTime.get_Kind -M:System.DateTime.get_Microsecond -M:System.DateTime.get_Millisecond -M:System.DateTime.get_Minute -M:System.DateTime.get_Month -M:System.DateTime.get_Nanosecond -M:System.DateTime.get_Now -M:System.DateTime.get_Second -M:System.DateTime.get_Ticks -M:System.DateTime.get_TimeOfDay -M:System.DateTime.get_Today -M:System.DateTime.get_UtcNow -M:System.DateTime.get_Year -M:System.DateTime.GetDateTimeFormats -M:System.DateTime.GetDateTimeFormats(System.Char) -M:System.DateTime.GetDateTimeFormats(System.Char,System.IFormatProvider) -M:System.DateTime.GetDateTimeFormats(System.IFormatProvider) -M:System.DateTime.GetHashCode -M:System.DateTime.GetTypeCode -M:System.DateTime.IsDaylightSavingTime -M:System.DateTime.IsLeapYear(System.Int32) -M:System.DateTime.op_Addition(System.DateTime,System.TimeSpan) -M:System.DateTime.op_Equality(System.DateTime,System.DateTime) -M:System.DateTime.op_GreaterThan(System.DateTime,System.DateTime) -M:System.DateTime.op_GreaterThanOrEqual(System.DateTime,System.DateTime) -M:System.DateTime.op_Inequality(System.DateTime,System.DateTime) -M:System.DateTime.op_LessThan(System.DateTime,System.DateTime) -M:System.DateTime.op_LessThanOrEqual(System.DateTime,System.DateTime) -M:System.DateTime.op_Subtraction(System.DateTime,System.DateTime) -M:System.DateTime.op_Subtraction(System.DateTime,System.TimeSpan) -M:System.DateTime.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateTime.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTime.Parse(System.String) -M:System.DateTime.Parse(System.String,System.IFormatProvider) -M:System.DateTime.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTime.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTime.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTime.ParseExact(System.String,System.String,System.IFormatProvider) -M:System.DateTime.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTime.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTime.SpecifyKind(System.DateTime,System.DateTimeKind) -M:System.DateTime.Subtract(System.DateTime) -M:System.DateTime.Subtract(System.TimeSpan) -M:System.DateTime.ToBinary -M:System.DateTime.ToFileTime -M:System.DateTime.ToFileTimeUtc -M:System.DateTime.ToLocalTime -M:System.DateTime.ToLongDateString -M:System.DateTime.ToLongTimeString -M:System.DateTime.ToOADate -M:System.DateTime.ToShortDateString -M:System.DateTime.ToShortTimeString -M:System.DateTime.ToString -M:System.DateTime.ToString(System.IFormatProvider) -M:System.DateTime.ToString(System.String) -M:System.DateTime.ToString(System.String,System.IFormatProvider) -M:System.DateTime.ToUniversalTime -M:System.DateTime.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateTime.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.DateTime@) -M:System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateTime@) -M:System.DateTime.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) -M:System.DateTime.TryParse(System.String,System.DateTime@) -M:System.DateTime.TryParse(System.String,System.IFormatProvider,System.DateTime@) -M:System.DateTime.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) -M:System.DateTime.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) -M:System.DateTime.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) -M:System.DateTime.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) -M:System.DateTime.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@) -M:System.DateTimeOffset.#ctor(System.DateOnly,System.TimeOnly,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.DateTime) -M:System.DateTimeOffset.#ctor(System.DateTime,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan) -M:System.DateTimeOffset.#ctor(System.Int64,System.TimeSpan) -M:System.DateTimeOffset.Add(System.TimeSpan) -M:System.DateTimeOffset.AddDays(System.Double) -M:System.DateTimeOffset.AddHours(System.Double) -M:System.DateTimeOffset.AddMicroseconds(System.Double) -M:System.DateTimeOffset.AddMilliseconds(System.Double) -M:System.DateTimeOffset.AddMinutes(System.Double) -M:System.DateTimeOffset.AddMonths(System.Int32) -M:System.DateTimeOffset.AddSeconds(System.Double) -M:System.DateTimeOffset.AddTicks(System.Int64) -M:System.DateTimeOffset.AddYears(System.Int32) -M:System.DateTimeOffset.Compare(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.CompareTo(System.DateTimeOffset) -M:System.DateTimeOffset.Deconstruct(System.DateOnly@,System.TimeOnly@,System.TimeSpan@) -M:System.DateTimeOffset.Equals(System.DateTimeOffset) -M:System.DateTimeOffset.Equals(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.Equals(System.Object) -M:System.DateTimeOffset.EqualsExact(System.DateTimeOffset) -M:System.DateTimeOffset.FromFileTime(System.Int64) -M:System.DateTimeOffset.FromUnixTimeMilliseconds(System.Int64) -M:System.DateTimeOffset.FromUnixTimeSeconds(System.Int64) -M:System.DateTimeOffset.get_Date -M:System.DateTimeOffset.get_DateTime -M:System.DateTimeOffset.get_Day -M:System.DateTimeOffset.get_DayOfWeek -M:System.DateTimeOffset.get_DayOfYear -M:System.DateTimeOffset.get_Hour -M:System.DateTimeOffset.get_LocalDateTime -M:System.DateTimeOffset.get_Microsecond -M:System.DateTimeOffset.get_Millisecond -M:System.DateTimeOffset.get_Minute -M:System.DateTimeOffset.get_Month -M:System.DateTimeOffset.get_Nanosecond -M:System.DateTimeOffset.get_Now -M:System.DateTimeOffset.get_Offset -M:System.DateTimeOffset.get_Second -M:System.DateTimeOffset.get_Ticks -M:System.DateTimeOffset.get_TimeOfDay -M:System.DateTimeOffset.get_TotalOffsetMinutes -M:System.DateTimeOffset.get_UtcDateTime -M:System.DateTimeOffset.get_UtcNow -M:System.DateTimeOffset.get_UtcTicks -M:System.DateTimeOffset.get_Year -M:System.DateTimeOffset.GetHashCode -M:System.DateTimeOffset.op_Addition(System.DateTimeOffset,System.TimeSpan) -M:System.DateTimeOffset.op_Equality(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_GreaterThan(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_GreaterThanOrEqual(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_Implicit(System.DateTime)~System.DateTimeOffset -M:System.DateTimeOffset.op_Inequality(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_LessThan(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_LessThanOrEqual(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_Subtraction(System.DateTimeOffset,System.DateTimeOffset) -M:System.DateTimeOffset.op_Subtraction(System.DateTimeOffset,System.TimeSpan) -M:System.DateTimeOffset.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateTimeOffset.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTimeOffset.Parse(System.String) -M:System.DateTimeOffset.Parse(System.String,System.IFormatProvider) -M:System.DateTimeOffset.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTimeOffset.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTimeOffset.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTimeOffset.ParseExact(System.String,System.String,System.IFormatProvider) -M:System.DateTimeOffset.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTimeOffset.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.DateTimeOffset.Subtract(System.DateTimeOffset) -M:System.DateTimeOffset.Subtract(System.TimeSpan) -M:System.DateTimeOffset.ToFileTime -M:System.DateTimeOffset.ToLocalTime -M:System.DateTimeOffset.ToOffset(System.TimeSpan) -M:System.DateTimeOffset.ToString -M:System.DateTimeOffset.ToString(System.IFormatProvider) -M:System.DateTimeOffset.ToString(System.String) -M:System.DateTimeOffset.ToString(System.String,System.IFormatProvider) -M:System.DateTimeOffset.ToUniversalTime -M:System.DateTimeOffset.ToUnixTimeMilliseconds -M:System.DateTimeOffset.ToUnixTimeSeconds -M:System.DateTimeOffset.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateTimeOffset.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.DateTimeOffset@) -M:System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParse(System.String,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParse(System.String,System.IFormatProvider,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) -M:System.DateTimeOffset.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@) -M:System.DBNull.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.DBNull.GetTypeCode -M:System.DBNull.ToString -M:System.DBNull.ToString(System.IFormatProvider) -M:System.Decimal.#ctor(System.Double) -M:System.Decimal.#ctor(System.Int32) -M:System.Decimal.#ctor(System.Int32,System.Int32,System.Int32,System.Boolean,System.Byte) -M:System.Decimal.#ctor(System.Int32[]) -M:System.Decimal.#ctor(System.Int64) -M:System.Decimal.#ctor(System.ReadOnlySpan{System.Int32}) -M:System.Decimal.#ctor(System.Single) -M:System.Decimal.#ctor(System.UInt32) -M:System.Decimal.#ctor(System.UInt64) -M:System.Decimal.Abs(System.Decimal) -M:System.Decimal.Add(System.Decimal,System.Decimal) -M:System.Decimal.Ceiling(System.Decimal) -M:System.Decimal.Clamp(System.Decimal,System.Decimal,System.Decimal) -M:System.Decimal.Compare(System.Decimal,System.Decimal) -M:System.Decimal.CompareTo(System.Decimal) -M:System.Decimal.CompareTo(System.Object) -M:System.Decimal.CopySign(System.Decimal,System.Decimal) -M:System.Decimal.CreateChecked``1(``0) -M:System.Decimal.CreateSaturating``1(``0) -M:System.Decimal.CreateTruncating``1(``0) -M:System.Decimal.Divide(System.Decimal,System.Decimal) -M:System.Decimal.Equals(System.Decimal) -M:System.Decimal.Equals(System.Decimal,System.Decimal) -M:System.Decimal.Equals(System.Object) -M:System.Decimal.Floor(System.Decimal) -M:System.Decimal.FromOACurrency(System.Int64) -M:System.Decimal.get_Scale -M:System.Decimal.GetBits(System.Decimal) -M:System.Decimal.GetBits(System.Decimal,System.Span{System.Int32}) -M:System.Decimal.GetHashCode -M:System.Decimal.GetTypeCode -M:System.Decimal.IsCanonical(System.Decimal) -M:System.Decimal.IsEvenInteger(System.Decimal) -M:System.Decimal.IsInteger(System.Decimal) -M:System.Decimal.IsNegative(System.Decimal) -M:System.Decimal.IsOddInteger(System.Decimal) -M:System.Decimal.IsPositive(System.Decimal) -M:System.Decimal.Max(System.Decimal,System.Decimal) -M:System.Decimal.MaxMagnitude(System.Decimal,System.Decimal) -M:System.Decimal.Min(System.Decimal,System.Decimal) -M:System.Decimal.MinMagnitude(System.Decimal,System.Decimal) -M:System.Decimal.Multiply(System.Decimal,System.Decimal) -M:System.Decimal.Negate(System.Decimal) -M:System.Decimal.op_Addition(System.Decimal,System.Decimal) -M:System.Decimal.op_Decrement(System.Decimal) -M:System.Decimal.op_Division(System.Decimal,System.Decimal) -M:System.Decimal.op_Equality(System.Decimal,System.Decimal) -M:System.Decimal.op_Explicit(System.Decimal)~System.Byte -M:System.Decimal.op_Explicit(System.Decimal)~System.Char -M:System.Decimal.op_Explicit(System.Decimal)~System.Double -M:System.Decimal.op_Explicit(System.Decimal)~System.Int16 -M:System.Decimal.op_Explicit(System.Decimal)~System.Int32 -M:System.Decimal.op_Explicit(System.Decimal)~System.Int64 -M:System.Decimal.op_Explicit(System.Decimal)~System.SByte -M:System.Decimal.op_Explicit(System.Decimal)~System.Single -M:System.Decimal.op_Explicit(System.Decimal)~System.UInt16 -M:System.Decimal.op_Explicit(System.Decimal)~System.UInt32 -M:System.Decimal.op_Explicit(System.Decimal)~System.UInt64 -M:System.Decimal.op_Explicit(System.Double)~System.Decimal -M:System.Decimal.op_Explicit(System.Single)~System.Decimal -M:System.Decimal.op_GreaterThan(System.Decimal,System.Decimal) -M:System.Decimal.op_GreaterThanOrEqual(System.Decimal,System.Decimal) -M:System.Decimal.op_Implicit(System.Byte)~System.Decimal -M:System.Decimal.op_Implicit(System.Char)~System.Decimal -M:System.Decimal.op_Implicit(System.Int16)~System.Decimal -M:System.Decimal.op_Implicit(System.Int32)~System.Decimal -M:System.Decimal.op_Implicit(System.Int64)~System.Decimal -M:System.Decimal.op_Implicit(System.SByte)~System.Decimal -M:System.Decimal.op_Implicit(System.UInt16)~System.Decimal -M:System.Decimal.op_Implicit(System.UInt32)~System.Decimal -M:System.Decimal.op_Implicit(System.UInt64)~System.Decimal -M:System.Decimal.op_Increment(System.Decimal) -M:System.Decimal.op_Inequality(System.Decimal,System.Decimal) -M:System.Decimal.op_LessThan(System.Decimal,System.Decimal) -M:System.Decimal.op_LessThanOrEqual(System.Decimal,System.Decimal) -M:System.Decimal.op_Modulus(System.Decimal,System.Decimal) -M:System.Decimal.op_Multiply(System.Decimal,System.Decimal) -M:System.Decimal.op_Subtraction(System.Decimal,System.Decimal) -M:System.Decimal.op_UnaryNegation(System.Decimal) -M:System.Decimal.op_UnaryPlus(System.Decimal) -M:System.Decimal.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Decimal.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Decimal.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Decimal.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Decimal.Parse(System.String) -M:System.Decimal.Parse(System.String,System.Globalization.NumberStyles) -M:System.Decimal.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Decimal.Parse(System.String,System.IFormatProvider) -M:System.Decimal.Remainder(System.Decimal,System.Decimal) -M:System.Decimal.Round(System.Decimal) -M:System.Decimal.Round(System.Decimal,System.Int32) -M:System.Decimal.Round(System.Decimal,System.Int32,System.MidpointRounding) -M:System.Decimal.Round(System.Decimal,System.MidpointRounding) -M:System.Decimal.Sign(System.Decimal) -M:System.Decimal.Subtract(System.Decimal,System.Decimal) -M:System.Decimal.ToByte(System.Decimal) -M:System.Decimal.ToDouble(System.Decimal) -M:System.Decimal.ToInt16(System.Decimal) -M:System.Decimal.ToInt32(System.Decimal) -M:System.Decimal.ToInt64(System.Decimal) -M:System.Decimal.ToOACurrency(System.Decimal) -M:System.Decimal.ToSByte(System.Decimal) -M:System.Decimal.ToSingle(System.Decimal) -M:System.Decimal.ToString -M:System.Decimal.ToString(System.IFormatProvider) -M:System.Decimal.ToString(System.String) -M:System.Decimal.ToString(System.String,System.IFormatProvider) -M:System.Decimal.ToUInt16(System.Decimal) -M:System.Decimal.ToUInt32(System.Decimal) -M:System.Decimal.ToUInt64(System.Decimal) -M:System.Decimal.Truncate(System.Decimal) -M:System.Decimal.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Decimal.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Decimal.TryGetBits(System.Decimal,System.Span{System.Int32},System.Int32@) -M:System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.Decimal@) -M:System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) -M:System.Decimal.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Decimal@) -M:System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.Decimal@) -M:System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) -M:System.Decimal.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Decimal@) -M:System.Decimal.TryParse(System.String,System.Decimal@) -M:System.Decimal.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@) -M:System.Decimal.TryParse(System.String,System.IFormatProvider,System.Decimal@) -M:System.Delegate.#ctor(System.Object,System.String) -M:System.Delegate.#ctor(System.Type,System.String) -M:System.Delegate.Clone -M:System.Delegate.Combine(System.Delegate,System.Delegate) -M:System.Delegate.Combine(System.Delegate[]) -M:System.Delegate.CombineImpl(System.Delegate) -M:System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo) -M:System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boolean) -M:System.Delegate.CreateDelegate(System.Type,System.Object,System.String) -M:System.Delegate.CreateDelegate(System.Type,System.Object,System.String,System.Boolean) -M:System.Delegate.CreateDelegate(System.Type,System.Object,System.String,System.Boolean,System.Boolean) -M:System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo) -M:System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo,System.Boolean) -M:System.Delegate.CreateDelegate(System.Type,System.Type,System.String) -M:System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean) -M:System.Delegate.CreateDelegate(System.Type,System.Type,System.String,System.Boolean,System.Boolean) -M:System.Delegate.DynamicInvoke(System.Object[]) -M:System.Delegate.DynamicInvokeImpl(System.Object[]) -M:System.Delegate.Equals(System.Object) -M:System.Delegate.get_Method -M:System.Delegate.get_Target -M:System.Delegate.GetHashCode -M:System.Delegate.GetInvocationList -M:System.Delegate.GetMethodImpl -M:System.Delegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Delegate.op_Equality(System.Delegate,System.Delegate) -M:System.Delegate.op_Inequality(System.Delegate,System.Delegate) -M:System.Delegate.Remove(System.Delegate,System.Delegate) -M:System.Delegate.RemoveAll(System.Delegate,System.Delegate) -M:System.Delegate.RemoveImpl(System.Delegate) -M:System.Diagnostics.CodeAnalysis.AllowNullAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.get_Max -M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.get_Min -M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.set_Max(System.Object) -M:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute.set_Min(System.Object) -M:System.Diagnostics.CodeAnalysis.DisallowNullAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.#ctor(System.Boolean) -M:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.get_ParameterValue -M:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes) -M:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.get_MemberTypes -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,System.String,System.String) -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,System.Type) -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String,System.String,System.String) -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.#ctor(System.String,System.Type) -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_AssemblyName -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_Condition -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_MemberSignature -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_MemberTypes -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_Type -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.get_TypeName -M:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute.set_Condition(System.String) -M:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.get_Justification -M:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute.set_Justification(System.String) -M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_DiagnosticId -M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.get_UrlFormat -M:System.Diagnostics.CodeAnalysis.ExperimentalAttribute.set_UrlFormat(System.String) -M:System.Diagnostics.CodeAnalysis.MaybeNullAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.#ctor(System.Boolean) -M:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.get_ReturnValue -M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String[]) -M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.get_Members -M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String) -M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String[]) -M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.get_Members -M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.get_ReturnValue -M:System.Diagnostics.CodeAnalysis.NotNullAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.get_ParameterName -M:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.#ctor(System.Boolean) -M:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.get_ReturnValue -M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.get_Message -M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.get_Url -M:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute.set_Url(System.String) -M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.get_Message -M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.get_Url -M:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.set_Url(System.String) -M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.get_Message -M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.get_Url -M:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.set_Url(System.String) -M:System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute.#ctor -M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.#ctor(System.String) -M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.#ctor(System.String,System.Object[]) -M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.get_Arguments -M:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.get_Syntax -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.#ctor(System.String,System.String) -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Category -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_CheckId -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Justification -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_MessageId -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Scope -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.get_Target -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Justification(System.String) -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_MessageId(System.String) -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Scope(System.String) -M:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute.set_Target(System.String) -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.#ctor(System.String,System.String) -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Category -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_CheckId -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Justification -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_MessageId -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Scope -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.get_Target -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Justification(System.String) -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_MessageId(System.String) -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Scope(System.String) -M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.set_Target(System.String) -M:System.Diagnostics.CodeAnalysis.UnscopedRefAttribute.#ctor -M:System.Diagnostics.ConditionalAttribute.#ctor(System.String) -M:System.Diagnostics.ConditionalAttribute.get_ConditionString -M:System.Diagnostics.Debug.Assert(System.Boolean) -M:System.Diagnostics.Debug.Assert(System.Boolean,System.Diagnostics.Debug.AssertInterpolatedStringHandler@) -M:System.Diagnostics.Debug.Assert(System.Boolean,System.Diagnostics.Debug.AssertInterpolatedStringHandler@,System.Diagnostics.Debug.AssertInterpolatedStringHandler@) -M:System.Diagnostics.Debug.Assert(System.Boolean,System.String) -M:System.Diagnostics.Debug.Assert(System.Boolean,System.String,System.String) -M:System.Diagnostics.Debug.Assert(System.Boolean,System.String,System.String,System.Object[]) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Boolean,System.Boolean@) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.String) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendFormatted``1(``0,System.String) -M:System.Diagnostics.Debug.AssertInterpolatedStringHandler.AppendLiteral(System.String) -M:System.Diagnostics.Debug.Close -M:System.Diagnostics.Debug.Fail(System.String) -M:System.Diagnostics.Debug.Fail(System.String,System.String) -M:System.Diagnostics.Debug.Flush -M:System.Diagnostics.Debug.get_AutoFlush -M:System.Diagnostics.Debug.get_IndentLevel -M:System.Diagnostics.Debug.get_IndentSize -M:System.Diagnostics.Debug.Indent -M:System.Diagnostics.Debug.Print(System.String) -M:System.Diagnostics.Debug.Print(System.String,System.Object[]) -M:System.Diagnostics.Debug.set_AutoFlush(System.Boolean) -M:System.Diagnostics.Debug.set_IndentLevel(System.Int32) -M:System.Diagnostics.Debug.set_IndentSize(System.Int32) -M:System.Diagnostics.Debug.Unindent -M:System.Diagnostics.Debug.Write(System.Object) -M:System.Diagnostics.Debug.Write(System.Object,System.String) -M:System.Diagnostics.Debug.Write(System.String) -M:System.Diagnostics.Debug.Write(System.String,System.String) -M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@) -M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@,System.String) -M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Object) -M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.Object,System.String) -M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.String) -M:System.Diagnostics.Debug.WriteIf(System.Boolean,System.String,System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Boolean,System.Boolean@) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendFormatted``1(``0,System.String) -M:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler.AppendLiteral(System.String) -M:System.Diagnostics.Debug.WriteLine(System.Object) -M:System.Diagnostics.Debug.WriteLine(System.Object,System.String) -M:System.Diagnostics.Debug.WriteLine(System.String) -M:System.Diagnostics.Debug.WriteLine(System.String,System.Object[]) -M:System.Diagnostics.Debug.WriteLine(System.String,System.String) -M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@) -M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Diagnostics.Debug.WriteIfInterpolatedStringHandler@,System.String) -M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Object) -M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.Object,System.String) -M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.String) -M:System.Diagnostics.Debug.WriteLineIf(System.Boolean,System.String,System.String) -M:System.Diagnostics.DebuggableAttribute.#ctor(System.Boolean,System.Boolean) -M:System.Diagnostics.DebuggableAttribute.#ctor(System.Diagnostics.DebuggableAttribute.DebuggingModes) -M:System.Diagnostics.DebuggableAttribute.get_DebuggingFlags -M:System.Diagnostics.DebuggableAttribute.get_IsJITOptimizerDisabled -M:System.Diagnostics.DebuggableAttribute.get_IsJITTrackingEnabled -M:System.Diagnostics.DebuggerBrowsableAttribute.#ctor(System.Diagnostics.DebuggerBrowsableState) -M:System.Diagnostics.DebuggerBrowsableAttribute.get_State -M:System.Diagnostics.DebuggerDisplayAttribute.#ctor(System.String) -M:System.Diagnostics.DebuggerDisplayAttribute.get_Name -M:System.Diagnostics.DebuggerDisplayAttribute.get_Target -M:System.Diagnostics.DebuggerDisplayAttribute.get_TargetTypeName -M:System.Diagnostics.DebuggerDisplayAttribute.get_Type -M:System.Diagnostics.DebuggerDisplayAttribute.get_Value -M:System.Diagnostics.DebuggerDisplayAttribute.set_Name(System.String) -M:System.Diagnostics.DebuggerDisplayAttribute.set_Target(System.Type) -M:System.Diagnostics.DebuggerDisplayAttribute.set_TargetTypeName(System.String) -M:System.Diagnostics.DebuggerDisplayAttribute.set_Type(System.String) -M:System.Diagnostics.DebuggerHiddenAttribute.#ctor -M:System.Diagnostics.DebuggerNonUserCodeAttribute.#ctor -M:System.Diagnostics.DebuggerStepperBoundaryAttribute.#ctor -M:System.Diagnostics.DebuggerStepThroughAttribute.#ctor -M:System.Diagnostics.DebuggerTypeProxyAttribute.#ctor(System.String) -M:System.Diagnostics.DebuggerTypeProxyAttribute.#ctor(System.Type) -M:System.Diagnostics.DebuggerTypeProxyAttribute.get_ProxyTypeName -M:System.Diagnostics.DebuggerTypeProxyAttribute.get_Target -M:System.Diagnostics.DebuggerTypeProxyAttribute.get_TargetTypeName -M:System.Diagnostics.DebuggerTypeProxyAttribute.set_Target(System.Type) -M:System.Diagnostics.DebuggerTypeProxyAttribute.set_TargetTypeName(System.String) -M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String) -M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String,System.String) -M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.String,System.Type) -M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type) -M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type,System.String) -M:System.Diagnostics.DebuggerVisualizerAttribute.#ctor(System.Type,System.Type) -M:System.Diagnostics.DebuggerVisualizerAttribute.get_Description -M:System.Diagnostics.DebuggerVisualizerAttribute.get_Target -M:System.Diagnostics.DebuggerVisualizerAttribute.get_TargetTypeName -M:System.Diagnostics.DebuggerVisualizerAttribute.get_VisualizerObjectSourceTypeName -M:System.Diagnostics.DebuggerVisualizerAttribute.get_VisualizerTypeName -M:System.Diagnostics.DebuggerVisualizerAttribute.set_Description(System.String) -M:System.Diagnostics.DebuggerVisualizerAttribute.set_Target(System.Type) -M:System.Diagnostics.DebuggerVisualizerAttribute.set_TargetTypeName(System.String) -M:System.Diagnostics.StackTraceHiddenAttribute.#ctor -M:System.Diagnostics.Stopwatch.#ctor -M:System.Diagnostics.Stopwatch.get_Elapsed -M:System.Diagnostics.Stopwatch.get_ElapsedMilliseconds -M:System.Diagnostics.Stopwatch.get_ElapsedTicks -M:System.Diagnostics.Stopwatch.get_IsRunning -M:System.Diagnostics.Stopwatch.GetElapsedTime(System.Int64) -M:System.Diagnostics.Stopwatch.GetElapsedTime(System.Int64,System.Int64) -M:System.Diagnostics.Stopwatch.GetTimestamp -M:System.Diagnostics.Stopwatch.Reset -M:System.Diagnostics.Stopwatch.Restart -M:System.Diagnostics.Stopwatch.Start -M:System.Diagnostics.Stopwatch.StartNew -M:System.Diagnostics.Stopwatch.Stop -M:System.Diagnostics.Stopwatch.ToString -M:System.Diagnostics.UnreachableException.#ctor -M:System.Diagnostics.UnreachableException.#ctor(System.String) -M:System.Diagnostics.UnreachableException.#ctor(System.String,System.Exception) -M:System.DivideByZeroException.#ctor -M:System.DivideByZeroException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.DivideByZeroException.#ctor(System.String) -M:System.DivideByZeroException.#ctor(System.String,System.Exception) -M:System.Double.Abs(System.Double) -M:System.Double.Acos(System.Double) -M:System.Double.Acosh(System.Double) -M:System.Double.AcosPi(System.Double) -M:System.Double.Asin(System.Double) -M:System.Double.Asinh(System.Double) -M:System.Double.AsinPi(System.Double) -M:System.Double.Atan(System.Double) -M:System.Double.Atan2(System.Double,System.Double) -M:System.Double.Atan2Pi(System.Double,System.Double) -M:System.Double.Atanh(System.Double) -M:System.Double.AtanPi(System.Double) -M:System.Double.BitDecrement(System.Double) -M:System.Double.BitIncrement(System.Double) -M:System.Double.Cbrt(System.Double) -M:System.Double.Ceiling(System.Double) -M:System.Double.Clamp(System.Double,System.Double,System.Double) -M:System.Double.CompareTo(System.Double) -M:System.Double.CompareTo(System.Object) -M:System.Double.CopySign(System.Double,System.Double) -M:System.Double.Cos(System.Double) -M:System.Double.Cosh(System.Double) -M:System.Double.CosPi(System.Double) -M:System.Double.CreateChecked``1(``0) -M:System.Double.CreateSaturating``1(``0) -M:System.Double.CreateTruncating``1(``0) -M:System.Double.DegreesToRadians(System.Double) -M:System.Double.Equals(System.Double) -M:System.Double.Equals(System.Object) -M:System.Double.Exp(System.Double) -M:System.Double.Exp10(System.Double) -M:System.Double.Exp10M1(System.Double) -M:System.Double.Exp2(System.Double) -M:System.Double.Exp2M1(System.Double) -M:System.Double.ExpM1(System.Double) -M:System.Double.Floor(System.Double) -M:System.Double.FusedMultiplyAdd(System.Double,System.Double,System.Double) -M:System.Double.GetHashCode -M:System.Double.GetTypeCode -M:System.Double.Hypot(System.Double,System.Double) -M:System.Double.Ieee754Remainder(System.Double,System.Double) -M:System.Double.ILogB(System.Double) -M:System.Double.IsEvenInteger(System.Double) -M:System.Double.IsFinite(System.Double) -M:System.Double.IsInfinity(System.Double) -M:System.Double.IsInteger(System.Double) -M:System.Double.IsNaN(System.Double) -M:System.Double.IsNegative(System.Double) -M:System.Double.IsNegativeInfinity(System.Double) -M:System.Double.IsNormal(System.Double) -M:System.Double.IsOddInteger(System.Double) -M:System.Double.IsPositive(System.Double) -M:System.Double.IsPositiveInfinity(System.Double) -M:System.Double.IsPow2(System.Double) -M:System.Double.IsRealNumber(System.Double) -M:System.Double.IsSubnormal(System.Double) -M:System.Double.Lerp(System.Double,System.Double,System.Double) -M:System.Double.Log(System.Double) -M:System.Double.Log(System.Double,System.Double) -M:System.Double.Log10(System.Double) -M:System.Double.Log10P1(System.Double) -M:System.Double.Log2(System.Double) -M:System.Double.Log2P1(System.Double) -M:System.Double.LogP1(System.Double) -M:System.Double.Max(System.Double,System.Double) -M:System.Double.MaxMagnitude(System.Double,System.Double) -M:System.Double.MaxMagnitudeNumber(System.Double,System.Double) -M:System.Double.MaxNumber(System.Double,System.Double) -M:System.Double.Min(System.Double,System.Double) -M:System.Double.MinMagnitude(System.Double,System.Double) -M:System.Double.MinMagnitudeNumber(System.Double,System.Double) -M:System.Double.MinNumber(System.Double,System.Double) -M:System.Double.op_Equality(System.Double,System.Double) -M:System.Double.op_GreaterThan(System.Double,System.Double) -M:System.Double.op_GreaterThanOrEqual(System.Double,System.Double) -M:System.Double.op_Inequality(System.Double,System.Double) -M:System.Double.op_LessThan(System.Double,System.Double) -M:System.Double.op_LessThanOrEqual(System.Double,System.Double) -M:System.Double.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Double.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Double.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Double.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Double.Parse(System.String) -M:System.Double.Parse(System.String,System.Globalization.NumberStyles) -M:System.Double.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Double.Parse(System.String,System.IFormatProvider) -M:System.Double.Pow(System.Double,System.Double) -M:System.Double.RadiansToDegrees(System.Double) -M:System.Double.ReciprocalEstimate(System.Double) -M:System.Double.ReciprocalSqrtEstimate(System.Double) -M:System.Double.RootN(System.Double,System.Int32) -M:System.Double.Round(System.Double) -M:System.Double.Round(System.Double,System.Int32) -M:System.Double.Round(System.Double,System.Int32,System.MidpointRounding) -M:System.Double.Round(System.Double,System.MidpointRounding) -M:System.Double.ScaleB(System.Double,System.Int32) -M:System.Double.Sign(System.Double) -M:System.Double.Sin(System.Double) -M:System.Double.SinCos(System.Double) -M:System.Double.SinCosPi(System.Double) -M:System.Double.Sinh(System.Double) -M:System.Double.SinPi(System.Double) -M:System.Double.Sqrt(System.Double) -M:System.Double.Tan(System.Double) -M:System.Double.Tanh(System.Double) -M:System.Double.TanPi(System.Double) -M:System.Double.ToString -M:System.Double.ToString(System.IFormatProvider) -M:System.Double.ToString(System.String) -M:System.Double.ToString(System.String,System.IFormatProvider) -M:System.Double.Truncate(System.Double) -M:System.Double.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Double.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.Double@) -M:System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) -M:System.Double.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Double@) -M:System.Double.TryParse(System.ReadOnlySpan{System.Char},System.Double@) -M:System.Double.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) -M:System.Double.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Double@) -M:System.Double.TryParse(System.String,System.Double@) -M:System.Double.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Double@) -M:System.Double.TryParse(System.String,System.IFormatProvider,System.Double@) -M:System.DuplicateWaitObjectException.#ctor -M:System.DuplicateWaitObjectException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.DuplicateWaitObjectException.#ctor(System.String) -M:System.DuplicateWaitObjectException.#ctor(System.String,System.Exception) -M:System.DuplicateWaitObjectException.#ctor(System.String,System.String) -M:System.EntryPointNotFoundException.#ctor -M:System.EntryPointNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.EntryPointNotFoundException.#ctor(System.String) -M:System.EntryPointNotFoundException.#ctor(System.String,System.Exception) -M:System.Enum.#ctor -M:System.Enum.CompareTo(System.Object) -M:System.Enum.Equals(System.Object) -M:System.Enum.Format(System.Type,System.Object,System.String) -M:System.Enum.GetHashCode -M:System.Enum.GetName(System.Type,System.Object) -M:System.Enum.GetName``1(``0) -M:System.Enum.GetNames(System.Type) -M:System.Enum.GetNames``1 -M:System.Enum.GetTypeCode -M:System.Enum.GetUnderlyingType(System.Type) -M:System.Enum.GetValues(System.Type) -M:System.Enum.GetValues``1 -M:System.Enum.GetValuesAsUnderlyingType(System.Type) -M:System.Enum.GetValuesAsUnderlyingType``1 -M:System.Enum.HasFlag(System.Enum) -M:System.Enum.IsDefined(System.Type,System.Object) -M:System.Enum.IsDefined``1(``0) -M:System.Enum.Parse(System.Type,System.ReadOnlySpan{System.Char}) -M:System.Enum.Parse(System.Type,System.ReadOnlySpan{System.Char},System.Boolean) -M:System.Enum.Parse(System.Type,System.String) -M:System.Enum.Parse(System.Type,System.String,System.Boolean) -M:System.Enum.Parse``1(System.ReadOnlySpan{System.Char}) -M:System.Enum.Parse``1(System.ReadOnlySpan{System.Char},System.Boolean) -M:System.Enum.Parse``1(System.String) -M:System.Enum.Parse``1(System.String,System.Boolean) -M:System.Enum.ToObject(System.Type,System.Byte) -M:System.Enum.ToObject(System.Type,System.Int16) -M:System.Enum.ToObject(System.Type,System.Int32) -M:System.Enum.ToObject(System.Type,System.Int64) -M:System.Enum.ToObject(System.Type,System.Object) -M:System.Enum.ToObject(System.Type,System.SByte) -M:System.Enum.ToObject(System.Type,System.UInt16) -M:System.Enum.ToObject(System.Type,System.UInt32) -M:System.Enum.ToObject(System.Type,System.UInt64) -M:System.Enum.ToString -M:System.Enum.ToString(System.IFormatProvider) -M:System.Enum.ToString(System.String) -M:System.Enum.ToString(System.String,System.IFormatProvider) -M:System.Enum.TryFormat``1(``0,System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char}) -M:System.Enum.TryParse(System.Type,System.ReadOnlySpan{System.Char},System.Boolean,System.Object@) -M:System.Enum.TryParse(System.Type,System.ReadOnlySpan{System.Char},System.Object@) -M:System.Enum.TryParse(System.Type,System.String,System.Boolean,System.Object@) -M:System.Enum.TryParse(System.Type,System.String,System.Object@) -M:System.Enum.TryParse``1(System.ReadOnlySpan{System.Char},``0@) -M:System.Enum.TryParse``1(System.ReadOnlySpan{System.Char},System.Boolean,``0@) -M:System.Enum.TryParse``1(System.String,``0@) -M:System.Enum.TryParse``1(System.String,System.Boolean,``0@) -M:System.Environment.get_CurrentManagedThreadId -M:System.Environment.get_NewLine -M:System.EventArgs.#ctor -M:System.EventHandler.#ctor(System.Object,System.IntPtr) -M:System.EventHandler.BeginInvoke(System.Object,System.EventArgs,System.AsyncCallback,System.Object) -M:System.EventHandler.EndInvoke(System.IAsyncResult) -M:System.EventHandler.Invoke(System.Object,System.EventArgs) -M:System.EventHandler`1.#ctor(System.Object,System.IntPtr) -M:System.EventHandler`1.BeginInvoke(System.Object,`0,System.AsyncCallback,System.Object) -M:System.EventHandler`1.EndInvoke(System.IAsyncResult) -M:System.EventHandler`1.Invoke(System.Object,`0) -M:System.Exception.#ctor -M:System.Exception.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Exception.#ctor(System.String) -M:System.Exception.#ctor(System.String,System.Exception) -M:System.Exception.add_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs}) -M:System.Exception.get_Data -M:System.Exception.get_HelpLink -M:System.Exception.get_HResult -M:System.Exception.get_InnerException -M:System.Exception.get_Message -M:System.Exception.get_Source -M:System.Exception.get_StackTrace -M:System.Exception.get_TargetSite -M:System.Exception.GetBaseException -M:System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Exception.GetType -M:System.Exception.remove_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs}) -M:System.Exception.set_HelpLink(System.String) -M:System.Exception.set_HResult(System.Int32) -M:System.Exception.set_Source(System.String) -M:System.Exception.ToString -M:System.ExecutionEngineException.#ctor -M:System.ExecutionEngineException.#ctor(System.String) -M:System.ExecutionEngineException.#ctor(System.String,System.Exception) -M:System.FieldAccessException.#ctor -M:System.FieldAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.FieldAccessException.#ctor(System.String) -M:System.FieldAccessException.#ctor(System.String,System.Exception) -M:System.FileStyleUriParser.#ctor -M:System.FlagsAttribute.#ctor -M:System.FormatException.#ctor -M:System.FormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.FormatException.#ctor(System.String) -M:System.FormatException.#ctor(System.String,System.Exception) -M:System.FormattableString.#ctor -M:System.FormattableString.CurrentCulture(System.FormattableString) -M:System.FormattableString.get_ArgumentCount -M:System.FormattableString.get_Format -M:System.FormattableString.GetArgument(System.Int32) -M:System.FormattableString.GetArguments -M:System.FormattableString.Invariant(System.FormattableString) -M:System.FormattableString.ToString -M:System.FormattableString.ToString(System.IFormatProvider) -M:System.FtpStyleUriParser.#ctor -M:System.Func`1.#ctor(System.Object,System.IntPtr) -M:System.Func`1.BeginInvoke(System.AsyncCallback,System.Object) -M:System.Func`1.EndInvoke(System.IAsyncResult) -M:System.Func`1.Invoke -M:System.Func`10.#ctor(System.Object,System.IntPtr) -M:System.Func`10.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,System.AsyncCallback,System.Object) -M:System.Func`10.EndInvoke(System.IAsyncResult) -M:System.Func`10.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8) -M:System.Func`11.#ctor(System.Object,System.IntPtr) -M:System.Func`11.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,System.AsyncCallback,System.Object) -M:System.Func`11.EndInvoke(System.IAsyncResult) -M:System.Func`11.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9) -M:System.Func`12.#ctor(System.Object,System.IntPtr) -M:System.Func`12.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,System.AsyncCallback,System.Object) -M:System.Func`12.EndInvoke(System.IAsyncResult) -M:System.Func`12.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10) -M:System.Func`13.#ctor(System.Object,System.IntPtr) -M:System.Func`13.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,System.AsyncCallback,System.Object) -M:System.Func`13.EndInvoke(System.IAsyncResult) -M:System.Func`13.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11) -M:System.Func`14.#ctor(System.Object,System.IntPtr) -M:System.Func`14.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,System.AsyncCallback,System.Object) -M:System.Func`14.EndInvoke(System.IAsyncResult) -M:System.Func`14.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12) -M:System.Func`15.#ctor(System.Object,System.IntPtr) -M:System.Func`15.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,System.AsyncCallback,System.Object) -M:System.Func`15.EndInvoke(System.IAsyncResult) -M:System.Func`15.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13) -M:System.Func`16.#ctor(System.Object,System.IntPtr) -M:System.Func`16.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,System.AsyncCallback,System.Object) -M:System.Func`16.EndInvoke(System.IAsyncResult) -M:System.Func`16.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14) -M:System.Func`17.#ctor(System.Object,System.IntPtr) -M:System.Func`17.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15,System.AsyncCallback,System.Object) -M:System.Func`17.EndInvoke(System.IAsyncResult) -M:System.Func`17.Invoke(`0,`1,`2,`3,`4,`5,`6,`7,`8,`9,`10,`11,`12,`13,`14,`15) -M:System.Func`2.#ctor(System.Object,System.IntPtr) -M:System.Func`2.BeginInvoke(`0,System.AsyncCallback,System.Object) -M:System.Func`2.EndInvoke(System.IAsyncResult) -M:System.Func`2.Invoke(`0) -M:System.Func`3.#ctor(System.Object,System.IntPtr) -M:System.Func`3.BeginInvoke(`0,`1,System.AsyncCallback,System.Object) -M:System.Func`3.EndInvoke(System.IAsyncResult) -M:System.Func`3.Invoke(`0,`1) -M:System.Func`4.#ctor(System.Object,System.IntPtr) -M:System.Func`4.BeginInvoke(`0,`1,`2,System.AsyncCallback,System.Object) -M:System.Func`4.EndInvoke(System.IAsyncResult) -M:System.Func`4.Invoke(`0,`1,`2) -M:System.Func`5.#ctor(System.Object,System.IntPtr) -M:System.Func`5.BeginInvoke(`0,`1,`2,`3,System.AsyncCallback,System.Object) -M:System.Func`5.EndInvoke(System.IAsyncResult) -M:System.Func`5.Invoke(`0,`1,`2,`3) -M:System.Func`6.#ctor(System.Object,System.IntPtr) -M:System.Func`6.BeginInvoke(`0,`1,`2,`3,`4,System.AsyncCallback,System.Object) -M:System.Func`6.EndInvoke(System.IAsyncResult) -M:System.Func`6.Invoke(`0,`1,`2,`3,`4) -M:System.Func`7.#ctor(System.Object,System.IntPtr) -M:System.Func`7.BeginInvoke(`0,`1,`2,`3,`4,`5,System.AsyncCallback,System.Object) -M:System.Func`7.EndInvoke(System.IAsyncResult) -M:System.Func`7.Invoke(`0,`1,`2,`3,`4,`5) -M:System.Func`8.#ctor(System.Object,System.IntPtr) -M:System.Func`8.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,System.AsyncCallback,System.Object) -M:System.Func`8.EndInvoke(System.IAsyncResult) -M:System.Func`8.Invoke(`0,`1,`2,`3,`4,`5,`6) -M:System.Func`9.#ctor(System.Object,System.IntPtr) -M:System.Func`9.BeginInvoke(`0,`1,`2,`3,`4,`5,`6,`7,System.AsyncCallback,System.Object) -M:System.Func`9.EndInvoke(System.IAsyncResult) -M:System.Func`9.Invoke(`0,`1,`2,`3,`4,`5,`6,`7) -M:System.GenericUriParser.#ctor(System.GenericUriParserOptions) -M:System.Globalization.Calendar.#ctor -M:System.Globalization.Calendar.AddDays(System.DateTime,System.Int32) -M:System.Globalization.Calendar.AddHours(System.DateTime,System.Int32) -M:System.Globalization.Calendar.AddMilliseconds(System.DateTime,System.Double) -M:System.Globalization.Calendar.AddMinutes(System.DateTime,System.Int32) -M:System.Globalization.Calendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.Calendar.AddSeconds(System.DateTime,System.Int32) -M:System.Globalization.Calendar.AddWeeks(System.DateTime,System.Int32) -M:System.Globalization.Calendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.Calendar.Clone -M:System.Globalization.Calendar.get_AlgorithmType -M:System.Globalization.Calendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.Calendar.get_Eras -M:System.Globalization.Calendar.get_IsReadOnly -M:System.Globalization.Calendar.get_MaxSupportedDateTime -M:System.Globalization.Calendar.get_MinSupportedDateTime -M:System.Globalization.Calendar.get_TwoDigitYearMax -M:System.Globalization.Calendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.Calendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.Calendar.GetDayOfYear(System.DateTime) -M:System.Globalization.Calendar.GetDaysInMonth(System.Int32,System.Int32) -M:System.Globalization.Calendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.Calendar.GetDaysInYear(System.Int32) -M:System.Globalization.Calendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.Calendar.GetEra(System.DateTime) -M:System.Globalization.Calendar.GetHour(System.DateTime) -M:System.Globalization.Calendar.GetLeapMonth(System.Int32) -M:System.Globalization.Calendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.Calendar.GetMilliseconds(System.DateTime) -M:System.Globalization.Calendar.GetMinute(System.DateTime) -M:System.Globalization.Calendar.GetMonth(System.DateTime) -M:System.Globalization.Calendar.GetMonthsInYear(System.Int32) -M:System.Globalization.Calendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.Calendar.GetSecond(System.DateTime) -M:System.Globalization.Calendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) -M:System.Globalization.Calendar.GetYear(System.DateTime) -M:System.Globalization.Calendar.IsLeapDay(System.Int32,System.Int32,System.Int32) -M:System.Globalization.Calendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.Calendar.IsLeapMonth(System.Int32,System.Int32) -M:System.Globalization.Calendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.Calendar.IsLeapYear(System.Int32) -M:System.Globalization.Calendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.Calendar.ReadOnly(System.Globalization.Calendar) -M:System.Globalization.Calendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.Calendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.Calendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.Calendar.ToFourDigitYear(System.Int32) -M:System.Globalization.CharUnicodeInfo.GetDecimalDigitValue(System.Char) -M:System.Globalization.CharUnicodeInfo.GetDecimalDigitValue(System.String,System.Int32) -M:System.Globalization.CharUnicodeInfo.GetDigitValue(System.Char) -M:System.Globalization.CharUnicodeInfo.GetDigitValue(System.String,System.Int32) -M:System.Globalization.CharUnicodeInfo.GetNumericValue(System.Char) -M:System.Globalization.CharUnicodeInfo.GetNumericValue(System.String,System.Int32) -M:System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Char) -M:System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Int32) -M:System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.String,System.Int32) -M:System.Globalization.ChineseLunisolarCalendar.#ctor -M:System.Globalization.ChineseLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.ChineseLunisolarCalendar.get_Eras -M:System.Globalization.ChineseLunisolarCalendar.get_MaxSupportedDateTime -M:System.Globalization.ChineseLunisolarCalendar.get_MinSupportedDateTime -M:System.Globalization.ChineseLunisolarCalendar.GetEra(System.DateTime) -M:System.Globalization.CompareInfo.Compare(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32) -M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.String,System.Int32) -M:System.Globalization.CompareInfo.Compare(System.String,System.Int32,System.String,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.Compare(System.String,System.String) -M:System.Globalization.CompareInfo.Compare(System.String,System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.Equals(System.Object) -M:System.Globalization.CompareInfo.get_LCID -M:System.Globalization.CompareInfo.get_Name -M:System.Globalization.CompareInfo.get_Version -M:System.Globalization.CompareInfo.GetCompareInfo(System.Int32) -M:System.Globalization.CompareInfo.GetCompareInfo(System.Int32,System.Reflection.Assembly) -M:System.Globalization.CompareInfo.GetCompareInfo(System.String) -M:System.Globalization.CompareInfo.GetCompareInfo(System.String,System.Reflection.Assembly) -M:System.Globalization.CompareInfo.GetHashCode -M:System.Globalization.CompareInfo.GetHashCode(System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.GetHashCode(System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.GetSortKey(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.GetSortKey(System.String) -M:System.Globalization.CompareInfo.GetSortKey(System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.GetSortKeyLength(System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) -M:System.Globalization.CompareInfo.IndexOf(System.ReadOnlySpan{System.Char},System.Text.Rune,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Int32) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.String) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Int32) -M:System.Globalization.CompareInfo.IndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IsPrefix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IsPrefix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) -M:System.Globalization.CompareInfo.IsPrefix(System.String,System.String) -M:System.Globalization.CompareInfo.IsPrefix(System.String,System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IsSortable(System.Char) -M:System.Globalization.CompareInfo.IsSortable(System.ReadOnlySpan{System.Char}) -M:System.Globalization.CompareInfo.IsSortable(System.String) -M:System.Globalization.CompareInfo.IsSortable(System.Text.Rune) -M:System.Globalization.CompareInfo.IsSuffix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.IsSuffix(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) -M:System.Globalization.CompareInfo.IsSuffix(System.String,System.String) -M:System.Globalization.CompareInfo.IsSuffix(System.String,System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Globalization.CompareOptions,System.Int32@) -M:System.Globalization.CompareInfo.LastIndexOf(System.ReadOnlySpan{System.Char},System.Text.Rune,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Int32) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Int32) -M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) -M:System.Globalization.CompareInfo.ToString -M:System.Globalization.CultureInfo.#ctor(System.Int32) -M:System.Globalization.CultureInfo.#ctor(System.Int32,System.Boolean) -M:System.Globalization.CultureInfo.#ctor(System.String) -M:System.Globalization.CultureInfo.#ctor(System.String,System.Boolean) -M:System.Globalization.CultureInfo.ClearCachedData -M:System.Globalization.CultureInfo.Clone -M:System.Globalization.CultureInfo.CreateSpecificCulture(System.String) -M:System.Globalization.CultureInfo.Equals(System.Object) -M:System.Globalization.CultureInfo.get_Calendar -M:System.Globalization.CultureInfo.get_CompareInfo -M:System.Globalization.CultureInfo.get_CultureTypes -M:System.Globalization.CultureInfo.get_CurrentCulture -M:System.Globalization.CultureInfo.get_CurrentUICulture -M:System.Globalization.CultureInfo.get_DateTimeFormat -M:System.Globalization.CultureInfo.get_DefaultThreadCurrentCulture -M:System.Globalization.CultureInfo.get_DefaultThreadCurrentUICulture -M:System.Globalization.CultureInfo.get_DisplayName -M:System.Globalization.CultureInfo.get_EnglishName -M:System.Globalization.CultureInfo.get_IetfLanguageTag -M:System.Globalization.CultureInfo.get_InstalledUICulture -M:System.Globalization.CultureInfo.get_InvariantCulture -M:System.Globalization.CultureInfo.get_IsNeutralCulture -M:System.Globalization.CultureInfo.get_IsReadOnly -M:System.Globalization.CultureInfo.get_KeyboardLayoutId -M:System.Globalization.CultureInfo.get_LCID -M:System.Globalization.CultureInfo.get_Name -M:System.Globalization.CultureInfo.get_NativeName -M:System.Globalization.CultureInfo.get_NumberFormat -M:System.Globalization.CultureInfo.get_OptionalCalendars -M:System.Globalization.CultureInfo.get_Parent -M:System.Globalization.CultureInfo.get_TextInfo -M:System.Globalization.CultureInfo.get_ThreeLetterISOLanguageName -M:System.Globalization.CultureInfo.get_ThreeLetterWindowsLanguageName -M:System.Globalization.CultureInfo.get_TwoLetterISOLanguageName -M:System.Globalization.CultureInfo.get_UseUserOverride -M:System.Globalization.CultureInfo.GetConsoleFallbackUICulture -M:System.Globalization.CultureInfo.GetCultureInfo(System.Int32) -M:System.Globalization.CultureInfo.GetCultureInfo(System.String) -M:System.Globalization.CultureInfo.GetCultureInfo(System.String,System.Boolean) -M:System.Globalization.CultureInfo.GetCultureInfo(System.String,System.String) -M:System.Globalization.CultureInfo.GetCultureInfoByIetfLanguageTag(System.String) -M:System.Globalization.CultureInfo.GetCultures(System.Globalization.CultureTypes) -M:System.Globalization.CultureInfo.GetFormat(System.Type) -M:System.Globalization.CultureInfo.GetHashCode -M:System.Globalization.CultureInfo.ReadOnly(System.Globalization.CultureInfo) -M:System.Globalization.CultureInfo.ToString -M:System.Globalization.CultureNotFoundException.#ctor -M:System.Globalization.CultureNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Globalization.CultureNotFoundException.#ctor(System.String) -M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.Exception) -M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.Int32,System.Exception) -M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.Int32,System.String) -M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.String) -M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.String,System.Exception) -M:System.Globalization.CultureNotFoundException.#ctor(System.String,System.String,System.String) -M:System.Globalization.CultureNotFoundException.get_InvalidCultureId -M:System.Globalization.CultureNotFoundException.get_InvalidCultureName -M:System.Globalization.CultureNotFoundException.get_Message -M:System.Globalization.CultureNotFoundException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Globalization.DateTimeFormatInfo.#ctor -M:System.Globalization.DateTimeFormatInfo.Clone -M:System.Globalization.DateTimeFormatInfo.get_AbbreviatedDayNames -M:System.Globalization.DateTimeFormatInfo.get_AbbreviatedMonthGenitiveNames -M:System.Globalization.DateTimeFormatInfo.get_AbbreviatedMonthNames -M:System.Globalization.DateTimeFormatInfo.get_AMDesignator -M:System.Globalization.DateTimeFormatInfo.get_Calendar -M:System.Globalization.DateTimeFormatInfo.get_CalendarWeekRule -M:System.Globalization.DateTimeFormatInfo.get_CurrentInfo -M:System.Globalization.DateTimeFormatInfo.get_DateSeparator -M:System.Globalization.DateTimeFormatInfo.get_DayNames -M:System.Globalization.DateTimeFormatInfo.get_FirstDayOfWeek -M:System.Globalization.DateTimeFormatInfo.get_FullDateTimePattern -M:System.Globalization.DateTimeFormatInfo.get_InvariantInfo -M:System.Globalization.DateTimeFormatInfo.get_IsReadOnly -M:System.Globalization.DateTimeFormatInfo.get_LongDatePattern -M:System.Globalization.DateTimeFormatInfo.get_LongTimePattern -M:System.Globalization.DateTimeFormatInfo.get_MonthDayPattern -M:System.Globalization.DateTimeFormatInfo.get_MonthGenitiveNames -M:System.Globalization.DateTimeFormatInfo.get_MonthNames -M:System.Globalization.DateTimeFormatInfo.get_NativeCalendarName -M:System.Globalization.DateTimeFormatInfo.get_PMDesignator -M:System.Globalization.DateTimeFormatInfo.get_RFC1123Pattern -M:System.Globalization.DateTimeFormatInfo.get_ShortDatePattern -M:System.Globalization.DateTimeFormatInfo.get_ShortestDayNames -M:System.Globalization.DateTimeFormatInfo.get_ShortTimePattern -M:System.Globalization.DateTimeFormatInfo.get_SortableDateTimePattern -M:System.Globalization.DateTimeFormatInfo.get_TimeSeparator -M:System.Globalization.DateTimeFormatInfo.get_UniversalSortableDateTimePattern -M:System.Globalization.DateTimeFormatInfo.get_YearMonthPattern -M:System.Globalization.DateTimeFormatInfo.GetAbbreviatedDayName(System.DayOfWeek) -M:System.Globalization.DateTimeFormatInfo.GetAbbreviatedEraName(System.Int32) -M:System.Globalization.DateTimeFormatInfo.GetAbbreviatedMonthName(System.Int32) -M:System.Globalization.DateTimeFormatInfo.GetAllDateTimePatterns -M:System.Globalization.DateTimeFormatInfo.GetAllDateTimePatterns(System.Char) -M:System.Globalization.DateTimeFormatInfo.GetDayName(System.DayOfWeek) -M:System.Globalization.DateTimeFormatInfo.GetEra(System.String) -M:System.Globalization.DateTimeFormatInfo.GetEraName(System.Int32) -M:System.Globalization.DateTimeFormatInfo.GetFormat(System.Type) -M:System.Globalization.DateTimeFormatInfo.GetInstance(System.IFormatProvider) -M:System.Globalization.DateTimeFormatInfo.GetMonthName(System.Int32) -M:System.Globalization.DateTimeFormatInfo.GetShortestDayName(System.DayOfWeek) -M:System.Globalization.DateTimeFormatInfo.ReadOnly(System.Globalization.DateTimeFormatInfo) -M:System.Globalization.DateTimeFormatInfo.set_AbbreviatedDayNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_AbbreviatedMonthGenitiveNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_AbbreviatedMonthNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_AMDesignator(System.String) -M:System.Globalization.DateTimeFormatInfo.set_Calendar(System.Globalization.Calendar) -M:System.Globalization.DateTimeFormatInfo.set_CalendarWeekRule(System.Globalization.CalendarWeekRule) -M:System.Globalization.DateTimeFormatInfo.set_DateSeparator(System.String) -M:System.Globalization.DateTimeFormatInfo.set_DayNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_FirstDayOfWeek(System.DayOfWeek) -M:System.Globalization.DateTimeFormatInfo.set_FullDateTimePattern(System.String) -M:System.Globalization.DateTimeFormatInfo.set_LongDatePattern(System.String) -M:System.Globalization.DateTimeFormatInfo.set_LongTimePattern(System.String) -M:System.Globalization.DateTimeFormatInfo.set_MonthDayPattern(System.String) -M:System.Globalization.DateTimeFormatInfo.set_MonthGenitiveNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_MonthNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_PMDesignator(System.String) -M:System.Globalization.DateTimeFormatInfo.set_ShortDatePattern(System.String) -M:System.Globalization.DateTimeFormatInfo.set_ShortestDayNames(System.String[]) -M:System.Globalization.DateTimeFormatInfo.set_ShortTimePattern(System.String) -M:System.Globalization.DateTimeFormatInfo.set_TimeSeparator(System.String) -M:System.Globalization.DateTimeFormatInfo.set_YearMonthPattern(System.String) -M:System.Globalization.DateTimeFormatInfo.SetAllDateTimePatterns(System.String[],System.Char) -M:System.Globalization.DaylightTime.#ctor(System.DateTime,System.DateTime,System.TimeSpan) -M:System.Globalization.DaylightTime.get_Delta -M:System.Globalization.DaylightTime.get_End -M:System.Globalization.DaylightTime.get_Start -M:System.Globalization.EastAsianLunisolarCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.get_AlgorithmType -M:System.Globalization.EastAsianLunisolarCalendar.get_TwoDigitYearMax -M:System.Globalization.EastAsianLunisolarCalendar.GetCelestialStem(System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.EastAsianLunisolarCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.EastAsianLunisolarCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.EastAsianLunisolarCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.GetMonth(System.DateTime) -M:System.Globalization.EastAsianLunisolarCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.GetSexagenaryYear(System.DateTime) -M:System.Globalization.EastAsianLunisolarCalendar.GetTerrestrialBranch(System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.GetYear(System.DateTime) -M:System.Globalization.EastAsianLunisolarCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.EastAsianLunisolarCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.GlobalizationExtensions.GetStringComparer(System.Globalization.CompareInfo,System.Globalization.CompareOptions) -M:System.Globalization.GregorianCalendar.#ctor -M:System.Globalization.GregorianCalendar.#ctor(System.Globalization.GregorianCalendarTypes) -M:System.Globalization.GregorianCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.GregorianCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.GregorianCalendar.get_AlgorithmType -M:System.Globalization.GregorianCalendar.get_CalendarType -M:System.Globalization.GregorianCalendar.get_Eras -M:System.Globalization.GregorianCalendar.get_MaxSupportedDateTime -M:System.Globalization.GregorianCalendar.get_MinSupportedDateTime -M:System.Globalization.GregorianCalendar.get_TwoDigitYearMax -M:System.Globalization.GregorianCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.GregorianCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.GregorianCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.GregorianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.GetEra(System.DateTime) -M:System.Globalization.GregorianCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.GetMonth(System.DateTime) -M:System.Globalization.GregorianCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.GetYear(System.DateTime) -M:System.Globalization.GregorianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.set_CalendarType(System.Globalization.GregorianCalendarTypes) -M:System.Globalization.GregorianCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.GregorianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.GregorianCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.HebrewCalendar.#ctor -M:System.Globalization.HebrewCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.HebrewCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.HebrewCalendar.get_AlgorithmType -M:System.Globalization.HebrewCalendar.get_Eras -M:System.Globalization.HebrewCalendar.get_MaxSupportedDateTime -M:System.Globalization.HebrewCalendar.get_MinSupportedDateTime -M:System.Globalization.HebrewCalendar.get_TwoDigitYearMax -M:System.Globalization.HebrewCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.HebrewCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.HebrewCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.HebrewCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.GetEra(System.DateTime) -M:System.Globalization.HebrewCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.GetMonth(System.DateTime) -M:System.Globalization.HebrewCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.GetYear(System.DateTime) -M:System.Globalization.HebrewCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.HebrewCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.HebrewCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.HijriCalendar.#ctor -M:System.Globalization.HijriCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.HijriCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.HijriCalendar.get_AlgorithmType -M:System.Globalization.HijriCalendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.HijriCalendar.get_Eras -M:System.Globalization.HijriCalendar.get_HijriAdjustment -M:System.Globalization.HijriCalendar.get_MaxSupportedDateTime -M:System.Globalization.HijriCalendar.get_MinSupportedDateTime -M:System.Globalization.HijriCalendar.get_TwoDigitYearMax -M:System.Globalization.HijriCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.HijriCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.HijriCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.HijriCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.GetEra(System.DateTime) -M:System.Globalization.HijriCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.GetMonth(System.DateTime) -M:System.Globalization.HijriCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.GetYear(System.DateTime) -M:System.Globalization.HijriCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.set_HijriAdjustment(System.Int32) -M:System.Globalization.HijriCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.HijriCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.HijriCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.IdnMapping.#ctor -M:System.Globalization.IdnMapping.Equals(System.Object) -M:System.Globalization.IdnMapping.get_AllowUnassigned -M:System.Globalization.IdnMapping.get_UseStd3AsciiRules -M:System.Globalization.IdnMapping.GetAscii(System.String) -M:System.Globalization.IdnMapping.GetAscii(System.String,System.Int32) -M:System.Globalization.IdnMapping.GetAscii(System.String,System.Int32,System.Int32) -M:System.Globalization.IdnMapping.GetHashCode -M:System.Globalization.IdnMapping.GetUnicode(System.String) -M:System.Globalization.IdnMapping.GetUnicode(System.String,System.Int32) -M:System.Globalization.IdnMapping.GetUnicode(System.String,System.Int32,System.Int32) -M:System.Globalization.IdnMapping.set_AllowUnassigned(System.Boolean) -M:System.Globalization.IdnMapping.set_UseStd3AsciiRules(System.Boolean) -M:System.Globalization.ISOWeek.GetWeekOfYear(System.DateTime) -M:System.Globalization.ISOWeek.GetWeeksInYear(System.Int32) -M:System.Globalization.ISOWeek.GetYear(System.DateTime) -M:System.Globalization.ISOWeek.GetYearEnd(System.Int32) -M:System.Globalization.ISOWeek.GetYearStart(System.Int32) -M:System.Globalization.ISOWeek.ToDateTime(System.Int32,System.Int32,System.DayOfWeek) -M:System.Globalization.JapaneseCalendar.#ctor -M:System.Globalization.JapaneseCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.JapaneseCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.JapaneseCalendar.get_AlgorithmType -M:System.Globalization.JapaneseCalendar.get_Eras -M:System.Globalization.JapaneseCalendar.get_MaxSupportedDateTime -M:System.Globalization.JapaneseCalendar.get_MinSupportedDateTime -M:System.Globalization.JapaneseCalendar.get_TwoDigitYearMax -M:System.Globalization.JapaneseCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.JapaneseCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.JapaneseCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.JapaneseCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.GetEra(System.DateTime) -M:System.Globalization.JapaneseCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.GetMonth(System.DateTime) -M:System.Globalization.JapaneseCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) -M:System.Globalization.JapaneseCalendar.GetYear(System.DateTime) -M:System.Globalization.JapaneseCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.JapaneseCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.JapaneseCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.JapaneseLunisolarCalendar.#ctor -M:System.Globalization.JapaneseLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.JapaneseLunisolarCalendar.get_Eras -M:System.Globalization.JapaneseLunisolarCalendar.get_MaxSupportedDateTime -M:System.Globalization.JapaneseLunisolarCalendar.get_MinSupportedDateTime -M:System.Globalization.JapaneseLunisolarCalendar.GetEra(System.DateTime) -M:System.Globalization.JulianCalendar.#ctor -M:System.Globalization.JulianCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.JulianCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.JulianCalendar.get_AlgorithmType -M:System.Globalization.JulianCalendar.get_Eras -M:System.Globalization.JulianCalendar.get_MaxSupportedDateTime -M:System.Globalization.JulianCalendar.get_MinSupportedDateTime -M:System.Globalization.JulianCalendar.get_TwoDigitYearMax -M:System.Globalization.JulianCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.JulianCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.JulianCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.JulianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.GetEra(System.DateTime) -M:System.Globalization.JulianCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.GetMonth(System.DateTime) -M:System.Globalization.JulianCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.GetYear(System.DateTime) -M:System.Globalization.JulianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.JulianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.JulianCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.KoreanCalendar.#ctor -M:System.Globalization.KoreanCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.KoreanCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.KoreanCalendar.get_AlgorithmType -M:System.Globalization.KoreanCalendar.get_Eras -M:System.Globalization.KoreanCalendar.get_MaxSupportedDateTime -M:System.Globalization.KoreanCalendar.get_MinSupportedDateTime -M:System.Globalization.KoreanCalendar.get_TwoDigitYearMax -M:System.Globalization.KoreanCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.KoreanCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.KoreanCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.KoreanCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.GetEra(System.DateTime) -M:System.Globalization.KoreanCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.GetMonth(System.DateTime) -M:System.Globalization.KoreanCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) -M:System.Globalization.KoreanCalendar.GetYear(System.DateTime) -M:System.Globalization.KoreanCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.KoreanCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.KoreanCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.KoreanLunisolarCalendar.#ctor -M:System.Globalization.KoreanLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.KoreanLunisolarCalendar.get_Eras -M:System.Globalization.KoreanLunisolarCalendar.get_MaxSupportedDateTime -M:System.Globalization.KoreanLunisolarCalendar.get_MinSupportedDateTime -M:System.Globalization.KoreanLunisolarCalendar.GetEra(System.DateTime) -M:System.Globalization.NumberFormatInfo.#ctor -M:System.Globalization.NumberFormatInfo.Clone -M:System.Globalization.NumberFormatInfo.get_CurrencyDecimalDigits -M:System.Globalization.NumberFormatInfo.get_CurrencyDecimalSeparator -M:System.Globalization.NumberFormatInfo.get_CurrencyGroupSeparator -M:System.Globalization.NumberFormatInfo.get_CurrencyGroupSizes -M:System.Globalization.NumberFormatInfo.get_CurrencyNegativePattern -M:System.Globalization.NumberFormatInfo.get_CurrencyPositivePattern -M:System.Globalization.NumberFormatInfo.get_CurrencySymbol -M:System.Globalization.NumberFormatInfo.get_CurrentInfo -M:System.Globalization.NumberFormatInfo.get_DigitSubstitution -M:System.Globalization.NumberFormatInfo.get_InvariantInfo -M:System.Globalization.NumberFormatInfo.get_IsReadOnly -M:System.Globalization.NumberFormatInfo.get_NaNSymbol -M:System.Globalization.NumberFormatInfo.get_NativeDigits -M:System.Globalization.NumberFormatInfo.get_NegativeInfinitySymbol -M:System.Globalization.NumberFormatInfo.get_NegativeSign -M:System.Globalization.NumberFormatInfo.get_NumberDecimalDigits -M:System.Globalization.NumberFormatInfo.get_NumberDecimalSeparator -M:System.Globalization.NumberFormatInfo.get_NumberGroupSeparator -M:System.Globalization.NumberFormatInfo.get_NumberGroupSizes -M:System.Globalization.NumberFormatInfo.get_NumberNegativePattern -M:System.Globalization.NumberFormatInfo.get_PercentDecimalDigits -M:System.Globalization.NumberFormatInfo.get_PercentDecimalSeparator -M:System.Globalization.NumberFormatInfo.get_PercentGroupSeparator -M:System.Globalization.NumberFormatInfo.get_PercentGroupSizes -M:System.Globalization.NumberFormatInfo.get_PercentNegativePattern -M:System.Globalization.NumberFormatInfo.get_PercentPositivePattern -M:System.Globalization.NumberFormatInfo.get_PercentSymbol -M:System.Globalization.NumberFormatInfo.get_PerMilleSymbol -M:System.Globalization.NumberFormatInfo.get_PositiveInfinitySymbol -M:System.Globalization.NumberFormatInfo.get_PositiveSign -M:System.Globalization.NumberFormatInfo.GetFormat(System.Type) -M:System.Globalization.NumberFormatInfo.GetInstance(System.IFormatProvider) -M:System.Globalization.NumberFormatInfo.ReadOnly(System.Globalization.NumberFormatInfo) -M:System.Globalization.NumberFormatInfo.set_CurrencyDecimalDigits(System.Int32) -M:System.Globalization.NumberFormatInfo.set_CurrencyDecimalSeparator(System.String) -M:System.Globalization.NumberFormatInfo.set_CurrencyGroupSeparator(System.String) -M:System.Globalization.NumberFormatInfo.set_CurrencyGroupSizes(System.Int32[]) -M:System.Globalization.NumberFormatInfo.set_CurrencyNegativePattern(System.Int32) -M:System.Globalization.NumberFormatInfo.set_CurrencyPositivePattern(System.Int32) -M:System.Globalization.NumberFormatInfo.set_CurrencySymbol(System.String) -M:System.Globalization.NumberFormatInfo.set_DigitSubstitution(System.Globalization.DigitShapes) -M:System.Globalization.NumberFormatInfo.set_NaNSymbol(System.String) -M:System.Globalization.NumberFormatInfo.set_NativeDigits(System.String[]) -M:System.Globalization.NumberFormatInfo.set_NegativeInfinitySymbol(System.String) -M:System.Globalization.NumberFormatInfo.set_NegativeSign(System.String) -M:System.Globalization.NumberFormatInfo.set_NumberDecimalDigits(System.Int32) -M:System.Globalization.NumberFormatInfo.set_NumberDecimalSeparator(System.String) -M:System.Globalization.NumberFormatInfo.set_NumberGroupSeparator(System.String) -M:System.Globalization.NumberFormatInfo.set_NumberGroupSizes(System.Int32[]) -M:System.Globalization.NumberFormatInfo.set_NumberNegativePattern(System.Int32) -M:System.Globalization.NumberFormatInfo.set_PercentDecimalDigits(System.Int32) -M:System.Globalization.NumberFormatInfo.set_PercentDecimalSeparator(System.String) -M:System.Globalization.NumberFormatInfo.set_PercentGroupSeparator(System.String) -M:System.Globalization.NumberFormatInfo.set_PercentGroupSizes(System.Int32[]) -M:System.Globalization.NumberFormatInfo.set_PercentNegativePattern(System.Int32) -M:System.Globalization.NumberFormatInfo.set_PercentPositivePattern(System.Int32) -M:System.Globalization.NumberFormatInfo.set_PercentSymbol(System.String) -M:System.Globalization.NumberFormatInfo.set_PerMilleSymbol(System.String) -M:System.Globalization.NumberFormatInfo.set_PositiveInfinitySymbol(System.String) -M:System.Globalization.NumberFormatInfo.set_PositiveSign(System.String) -M:System.Globalization.PersianCalendar.#ctor -M:System.Globalization.PersianCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.PersianCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.PersianCalendar.get_AlgorithmType -M:System.Globalization.PersianCalendar.get_Eras -M:System.Globalization.PersianCalendar.get_MaxSupportedDateTime -M:System.Globalization.PersianCalendar.get_MinSupportedDateTime -M:System.Globalization.PersianCalendar.get_TwoDigitYearMax -M:System.Globalization.PersianCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.PersianCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.PersianCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.PersianCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.GetEra(System.DateTime) -M:System.Globalization.PersianCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.GetMonth(System.DateTime) -M:System.Globalization.PersianCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.GetYear(System.DateTime) -M:System.Globalization.PersianCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.PersianCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.PersianCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.RegionInfo.#ctor(System.Int32) -M:System.Globalization.RegionInfo.#ctor(System.String) -M:System.Globalization.RegionInfo.Equals(System.Object) -M:System.Globalization.RegionInfo.get_CurrencyEnglishName -M:System.Globalization.RegionInfo.get_CurrencyNativeName -M:System.Globalization.RegionInfo.get_CurrencySymbol -M:System.Globalization.RegionInfo.get_CurrentRegion -M:System.Globalization.RegionInfo.get_DisplayName -M:System.Globalization.RegionInfo.get_EnglishName -M:System.Globalization.RegionInfo.get_GeoId -M:System.Globalization.RegionInfo.get_IsMetric -M:System.Globalization.RegionInfo.get_ISOCurrencySymbol -M:System.Globalization.RegionInfo.get_Name -M:System.Globalization.RegionInfo.get_NativeName -M:System.Globalization.RegionInfo.get_ThreeLetterISORegionName -M:System.Globalization.RegionInfo.get_ThreeLetterWindowsRegionName -M:System.Globalization.RegionInfo.get_TwoLetterISORegionName -M:System.Globalization.RegionInfo.GetHashCode -M:System.Globalization.RegionInfo.ToString -M:System.Globalization.SortKey.Compare(System.Globalization.SortKey,System.Globalization.SortKey) -M:System.Globalization.SortKey.Equals(System.Object) -M:System.Globalization.SortKey.get_KeyData -M:System.Globalization.SortKey.get_OriginalString -M:System.Globalization.SortKey.GetHashCode -M:System.Globalization.SortKey.ToString -M:System.Globalization.SortVersion.#ctor(System.Int32,System.Guid) -M:System.Globalization.SortVersion.Equals(System.Globalization.SortVersion) -M:System.Globalization.SortVersion.Equals(System.Object) -M:System.Globalization.SortVersion.get_FullVersion -M:System.Globalization.SortVersion.get_SortId -M:System.Globalization.SortVersion.GetHashCode -M:System.Globalization.SortVersion.op_Equality(System.Globalization.SortVersion,System.Globalization.SortVersion) -M:System.Globalization.SortVersion.op_Inequality(System.Globalization.SortVersion,System.Globalization.SortVersion) -M:System.Globalization.StringInfo.#ctor -M:System.Globalization.StringInfo.#ctor(System.String) -M:System.Globalization.StringInfo.Equals(System.Object) -M:System.Globalization.StringInfo.get_LengthInTextElements -M:System.Globalization.StringInfo.get_String -M:System.Globalization.StringInfo.GetHashCode -M:System.Globalization.StringInfo.GetNextTextElement(System.String) -M:System.Globalization.StringInfo.GetNextTextElement(System.String,System.Int32) -M:System.Globalization.StringInfo.GetNextTextElementLength(System.ReadOnlySpan{System.Char}) -M:System.Globalization.StringInfo.GetNextTextElementLength(System.String) -M:System.Globalization.StringInfo.GetNextTextElementLength(System.String,System.Int32) -M:System.Globalization.StringInfo.GetTextElementEnumerator(System.String) -M:System.Globalization.StringInfo.GetTextElementEnumerator(System.String,System.Int32) -M:System.Globalization.StringInfo.ParseCombiningCharacters(System.String) -M:System.Globalization.StringInfo.set_String(System.String) -M:System.Globalization.StringInfo.SubstringByTextElements(System.Int32) -M:System.Globalization.StringInfo.SubstringByTextElements(System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.#ctor -M:System.Globalization.TaiwanCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.TaiwanCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.TaiwanCalendar.get_AlgorithmType -M:System.Globalization.TaiwanCalendar.get_Eras -M:System.Globalization.TaiwanCalendar.get_MaxSupportedDateTime -M:System.Globalization.TaiwanCalendar.get_MinSupportedDateTime -M:System.Globalization.TaiwanCalendar.get_TwoDigitYearMax -M:System.Globalization.TaiwanCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.TaiwanCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.TaiwanCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.TaiwanCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.GetEra(System.DateTime) -M:System.Globalization.TaiwanCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.GetMonth(System.DateTime) -M:System.Globalization.TaiwanCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) -M:System.Globalization.TaiwanCalendar.GetYear(System.DateTime) -M:System.Globalization.TaiwanCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.TaiwanCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.TaiwanCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.TaiwanLunisolarCalendar.#ctor -M:System.Globalization.TaiwanLunisolarCalendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.TaiwanLunisolarCalendar.get_Eras -M:System.Globalization.TaiwanLunisolarCalendar.get_MaxSupportedDateTime -M:System.Globalization.TaiwanLunisolarCalendar.get_MinSupportedDateTime -M:System.Globalization.TaiwanLunisolarCalendar.GetEra(System.DateTime) -M:System.Globalization.TextElementEnumerator.get_Current -M:System.Globalization.TextElementEnumerator.get_ElementIndex -M:System.Globalization.TextElementEnumerator.GetTextElement -M:System.Globalization.TextElementEnumerator.MoveNext -M:System.Globalization.TextElementEnumerator.Reset -M:System.Globalization.TextInfo.Clone -M:System.Globalization.TextInfo.Equals(System.Object) -M:System.Globalization.TextInfo.get_ANSICodePage -M:System.Globalization.TextInfo.get_CultureName -M:System.Globalization.TextInfo.get_EBCDICCodePage -M:System.Globalization.TextInfo.get_IsReadOnly -M:System.Globalization.TextInfo.get_IsRightToLeft -M:System.Globalization.TextInfo.get_LCID -M:System.Globalization.TextInfo.get_ListSeparator -M:System.Globalization.TextInfo.get_MacCodePage -M:System.Globalization.TextInfo.get_OEMCodePage -M:System.Globalization.TextInfo.GetHashCode -M:System.Globalization.TextInfo.ReadOnly(System.Globalization.TextInfo) -M:System.Globalization.TextInfo.set_ListSeparator(System.String) -M:System.Globalization.TextInfo.ToLower(System.Char) -M:System.Globalization.TextInfo.ToLower(System.String) -M:System.Globalization.TextInfo.ToString -M:System.Globalization.TextInfo.ToTitleCase(System.String) -M:System.Globalization.TextInfo.ToUpper(System.Char) -M:System.Globalization.TextInfo.ToUpper(System.String) -M:System.Globalization.ThaiBuddhistCalendar.#ctor -M:System.Globalization.ThaiBuddhistCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.get_AlgorithmType -M:System.Globalization.ThaiBuddhistCalendar.get_Eras -M:System.Globalization.ThaiBuddhistCalendar.get_MaxSupportedDateTime -M:System.Globalization.ThaiBuddhistCalendar.get_MinSupportedDateTime -M:System.Globalization.ThaiBuddhistCalendar.get_TwoDigitYearMax -M:System.Globalization.ThaiBuddhistCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.ThaiBuddhistCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.ThaiBuddhistCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.ThaiBuddhistCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.GetEra(System.DateTime) -M:System.Globalization.ThaiBuddhistCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.GetMonth(System.DateTime) -M:System.Globalization.ThaiBuddhistCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek) -M:System.Globalization.ThaiBuddhistCalendar.GetYear(System.DateTime) -M:System.Globalization.ThaiBuddhistCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.ThaiBuddhistCalendar.ToFourDigitYear(System.Int32) -M:System.Globalization.UmAlQuraCalendar.#ctor -M:System.Globalization.UmAlQuraCalendar.AddMonths(System.DateTime,System.Int32) -M:System.Globalization.UmAlQuraCalendar.AddYears(System.DateTime,System.Int32) -M:System.Globalization.UmAlQuraCalendar.get_AlgorithmType -M:System.Globalization.UmAlQuraCalendar.get_DaysInYearBeforeMinSupportedYear -M:System.Globalization.UmAlQuraCalendar.get_Eras -M:System.Globalization.UmAlQuraCalendar.get_MaxSupportedDateTime -M:System.Globalization.UmAlQuraCalendar.get_MinSupportedDateTime -M:System.Globalization.UmAlQuraCalendar.get_TwoDigitYearMax -M:System.Globalization.UmAlQuraCalendar.GetDayOfMonth(System.DateTime) -M:System.Globalization.UmAlQuraCalendar.GetDayOfWeek(System.DateTime) -M:System.Globalization.UmAlQuraCalendar.GetDayOfYear(System.DateTime) -M:System.Globalization.UmAlQuraCalendar.GetDaysInMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.GetDaysInYear(System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.GetEra(System.DateTime) -M:System.Globalization.UmAlQuraCalendar.GetLeapMonth(System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.GetMonth(System.DateTime) -M:System.Globalization.UmAlQuraCalendar.GetMonthsInYear(System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.GetYear(System.DateTime) -M:System.Globalization.UmAlQuraCalendar.IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.IsLeapMonth(System.Int32,System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.IsLeapYear(System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.set_TwoDigitYearMax(System.Int32) -M:System.Globalization.UmAlQuraCalendar.ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Globalization.UmAlQuraCalendar.ToFourDigitYear(System.Int32) -M:System.GopherStyleUriParser.#ctor -M:System.Guid.#ctor(System.Byte[]) -M:System.Guid.#ctor(System.Int32,System.Int16,System.Int16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) -M:System.Guid.#ctor(System.Int32,System.Int16,System.Int16,System.Byte[]) -M:System.Guid.#ctor(System.ReadOnlySpan{System.Byte}) -M:System.Guid.#ctor(System.ReadOnlySpan{System.Byte},System.Boolean) -M:System.Guid.#ctor(System.String) -M:System.Guid.#ctor(System.UInt32,System.UInt16,System.UInt16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte) -M:System.Guid.CompareTo(System.Guid) -M:System.Guid.CompareTo(System.Object) -M:System.Guid.Equals(System.Guid) -M:System.Guid.Equals(System.Object) -M:System.Guid.GetHashCode -M:System.Guid.NewGuid -M:System.Guid.op_Equality(System.Guid,System.Guid) -M:System.Guid.op_GreaterThan(System.Guid,System.Guid) -M:System.Guid.op_GreaterThanOrEqual(System.Guid,System.Guid) -M:System.Guid.op_Inequality(System.Guid,System.Guid) -M:System.Guid.op_LessThan(System.Guid,System.Guid) -M:System.Guid.op_LessThanOrEqual(System.Guid,System.Guid) -M:System.Guid.Parse(System.ReadOnlySpan{System.Char}) -M:System.Guid.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Guid.Parse(System.String) -M:System.Guid.Parse(System.String,System.IFormatProvider) -M:System.Guid.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:System.Guid.ParseExact(System.String,System.String) -M:System.Guid.ToByteArray -M:System.Guid.ToByteArray(System.Boolean) -M:System.Guid.ToString -M:System.Guid.ToString(System.String) -M:System.Guid.ToString(System.String,System.IFormatProvider) -M:System.Guid.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char}) -M:System.Guid.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char}) -M:System.Guid.TryParse(System.ReadOnlySpan{System.Char},System.Guid@) -M:System.Guid.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Guid@) -M:System.Guid.TryParse(System.String,System.Guid@) -M:System.Guid.TryParse(System.String,System.IFormatProvider,System.Guid@) -M:System.Guid.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Guid@) -M:System.Guid.TryParseExact(System.String,System.String,System.Guid@) -M:System.Guid.TryWriteBytes(System.Span{System.Byte}) -M:System.Guid.TryWriteBytes(System.Span{System.Byte},System.Boolean,System.Int32@) -M:System.Half.Abs(System.Half) -M:System.Half.Acos(System.Half) -M:System.Half.Acosh(System.Half) -M:System.Half.AcosPi(System.Half) -M:System.Half.Asin(System.Half) -M:System.Half.Asinh(System.Half) -M:System.Half.AsinPi(System.Half) -M:System.Half.Atan(System.Half) -M:System.Half.Atan2(System.Half,System.Half) -M:System.Half.Atan2Pi(System.Half,System.Half) -M:System.Half.Atanh(System.Half) -M:System.Half.AtanPi(System.Half) -M:System.Half.BitDecrement(System.Half) -M:System.Half.BitIncrement(System.Half) -M:System.Half.Cbrt(System.Half) -M:System.Half.Ceiling(System.Half) -M:System.Half.Clamp(System.Half,System.Half,System.Half) -M:System.Half.CompareTo(System.Half) -M:System.Half.CompareTo(System.Object) -M:System.Half.CopySign(System.Half,System.Half) -M:System.Half.Cos(System.Half) -M:System.Half.Cosh(System.Half) -M:System.Half.CosPi(System.Half) -M:System.Half.CreateChecked``1(``0) -M:System.Half.CreateSaturating``1(``0) -M:System.Half.CreateTruncating``1(``0) -M:System.Half.DegreesToRadians(System.Half) -M:System.Half.Equals(System.Half) -M:System.Half.Equals(System.Object) -M:System.Half.Exp(System.Half) -M:System.Half.Exp10(System.Half) -M:System.Half.Exp10M1(System.Half) -M:System.Half.Exp2(System.Half) -M:System.Half.Exp2M1(System.Half) -M:System.Half.ExpM1(System.Half) -M:System.Half.Floor(System.Half) -M:System.Half.FusedMultiplyAdd(System.Half,System.Half,System.Half) -M:System.Half.get_E -M:System.Half.get_Epsilon -M:System.Half.get_MaxValue -M:System.Half.get_MinValue -M:System.Half.get_MultiplicativeIdentity -M:System.Half.get_NaN -M:System.Half.get_NegativeInfinity -M:System.Half.get_NegativeOne -M:System.Half.get_NegativeZero -M:System.Half.get_One -M:System.Half.get_Pi -M:System.Half.get_PositiveInfinity -M:System.Half.get_Tau -M:System.Half.get_Zero -M:System.Half.GetHashCode -M:System.Half.Hypot(System.Half,System.Half) -M:System.Half.Ieee754Remainder(System.Half,System.Half) -M:System.Half.ILogB(System.Half) -M:System.Half.IsEvenInteger(System.Half) -M:System.Half.IsFinite(System.Half) -M:System.Half.IsInfinity(System.Half) -M:System.Half.IsInteger(System.Half) -M:System.Half.IsNaN(System.Half) -M:System.Half.IsNegative(System.Half) -M:System.Half.IsNegativeInfinity(System.Half) -M:System.Half.IsNormal(System.Half) -M:System.Half.IsOddInteger(System.Half) -M:System.Half.IsPositive(System.Half) -M:System.Half.IsPositiveInfinity(System.Half) -M:System.Half.IsPow2(System.Half) -M:System.Half.IsRealNumber(System.Half) -M:System.Half.IsSubnormal(System.Half) -M:System.Half.Lerp(System.Half,System.Half,System.Half) -M:System.Half.Log(System.Half) -M:System.Half.Log(System.Half,System.Half) -M:System.Half.Log10(System.Half) -M:System.Half.Log10P1(System.Half) -M:System.Half.Log2(System.Half) -M:System.Half.Log2P1(System.Half) -M:System.Half.LogP1(System.Half) -M:System.Half.Max(System.Half,System.Half) -M:System.Half.MaxMagnitude(System.Half,System.Half) -M:System.Half.MaxMagnitudeNumber(System.Half,System.Half) -M:System.Half.MaxNumber(System.Half,System.Half) -M:System.Half.Min(System.Half,System.Half) -M:System.Half.MinMagnitude(System.Half,System.Half) -M:System.Half.MinMagnitudeNumber(System.Half,System.Half) -M:System.Half.MinNumber(System.Half,System.Half) -M:System.Half.op_Addition(System.Half,System.Half) -M:System.Half.op_CheckedExplicit(System.Half)~System.Byte -M:System.Half.op_CheckedExplicit(System.Half)~System.Char -M:System.Half.op_CheckedExplicit(System.Half)~System.Int128 -M:System.Half.op_CheckedExplicit(System.Half)~System.Int16 -M:System.Half.op_CheckedExplicit(System.Half)~System.Int32 -M:System.Half.op_CheckedExplicit(System.Half)~System.Int64 -M:System.Half.op_CheckedExplicit(System.Half)~System.IntPtr -M:System.Half.op_CheckedExplicit(System.Half)~System.SByte -M:System.Half.op_CheckedExplicit(System.Half)~System.UInt128 -M:System.Half.op_CheckedExplicit(System.Half)~System.UInt16 -M:System.Half.op_CheckedExplicit(System.Half)~System.UInt32 -M:System.Half.op_CheckedExplicit(System.Half)~System.UInt64 -M:System.Half.op_CheckedExplicit(System.Half)~System.UIntPtr -M:System.Half.op_Decrement(System.Half) -M:System.Half.op_Division(System.Half,System.Half) -M:System.Half.op_Equality(System.Half,System.Half) -M:System.Half.op_Explicit(System.Char)~System.Half -M:System.Half.op_Explicit(System.Decimal)~System.Half -M:System.Half.op_Explicit(System.Double)~System.Half -M:System.Half.op_Explicit(System.Half)~System.Byte -M:System.Half.op_Explicit(System.Half)~System.Char -M:System.Half.op_Explicit(System.Half)~System.Decimal -M:System.Half.op_Explicit(System.Half)~System.Double -M:System.Half.op_Explicit(System.Half)~System.Int128 -M:System.Half.op_Explicit(System.Half)~System.Int16 -M:System.Half.op_Explicit(System.Half)~System.Int32 -M:System.Half.op_Explicit(System.Half)~System.Int64 -M:System.Half.op_Explicit(System.Half)~System.IntPtr -M:System.Half.op_Explicit(System.Half)~System.SByte -M:System.Half.op_Explicit(System.Half)~System.Single -M:System.Half.op_Explicit(System.Half)~System.UInt128 -M:System.Half.op_Explicit(System.Half)~System.UInt16 -M:System.Half.op_Explicit(System.Half)~System.UInt32 -M:System.Half.op_Explicit(System.Half)~System.UInt64 -M:System.Half.op_Explicit(System.Half)~System.UIntPtr -M:System.Half.op_Explicit(System.Int16)~System.Half -M:System.Half.op_Explicit(System.Int32)~System.Half -M:System.Half.op_Explicit(System.Int64)~System.Half -M:System.Half.op_Explicit(System.IntPtr)~System.Half -M:System.Half.op_Explicit(System.Single)~System.Half -M:System.Half.op_Explicit(System.UInt16)~System.Half -M:System.Half.op_Explicit(System.UInt32)~System.Half -M:System.Half.op_Explicit(System.UInt64)~System.Half -M:System.Half.op_Explicit(System.UIntPtr)~System.Half -M:System.Half.op_GreaterThan(System.Half,System.Half) -M:System.Half.op_GreaterThanOrEqual(System.Half,System.Half) -M:System.Half.op_Implicit(System.Byte)~System.Half -M:System.Half.op_Implicit(System.SByte)~System.Half -M:System.Half.op_Increment(System.Half) -M:System.Half.op_Inequality(System.Half,System.Half) -M:System.Half.op_LessThan(System.Half,System.Half) -M:System.Half.op_LessThanOrEqual(System.Half,System.Half) -M:System.Half.op_Modulus(System.Half,System.Half) -M:System.Half.op_Multiply(System.Half,System.Half) -M:System.Half.op_Subtraction(System.Half,System.Half) -M:System.Half.op_UnaryNegation(System.Half) -M:System.Half.op_UnaryPlus(System.Half) -M:System.Half.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Half.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Half.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Half.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Half.Parse(System.String) -M:System.Half.Parse(System.String,System.Globalization.NumberStyles) -M:System.Half.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Half.Parse(System.String,System.IFormatProvider) -M:System.Half.Pow(System.Half,System.Half) -M:System.Half.RadiansToDegrees(System.Half) -M:System.Half.ReciprocalEstimate(System.Half) -M:System.Half.ReciprocalSqrtEstimate(System.Half) -M:System.Half.RootN(System.Half,System.Int32) -M:System.Half.Round(System.Half) -M:System.Half.Round(System.Half,System.Int32) -M:System.Half.Round(System.Half,System.Int32,System.MidpointRounding) -M:System.Half.Round(System.Half,System.MidpointRounding) -M:System.Half.ScaleB(System.Half,System.Int32) -M:System.Half.Sign(System.Half) -M:System.Half.Sin(System.Half) -M:System.Half.SinCos(System.Half) -M:System.Half.SinCosPi(System.Half) -M:System.Half.Sinh(System.Half) -M:System.Half.SinPi(System.Half) -M:System.Half.Sqrt(System.Half) -M:System.Half.Tan(System.Half) -M:System.Half.Tanh(System.Half) -M:System.Half.TanPi(System.Half) -M:System.Half.ToString -M:System.Half.ToString(System.IFormatProvider) -M:System.Half.ToString(System.String) -M:System.Half.ToString(System.String,System.IFormatProvider) -M:System.Half.Truncate(System.Half) -M:System.Half.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Half.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) -M:System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.Half@) -M:System.Half.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Half@) -M:System.Half.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) -M:System.Half.TryParse(System.ReadOnlySpan{System.Char},System.Half@) -M:System.Half.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Half@) -M:System.Half.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Half@) -M:System.Half.TryParse(System.String,System.Half@) -M:System.Half.TryParse(System.String,System.IFormatProvider,System.Half@) -M:System.HashCode.Add``1(``0) -M:System.HashCode.Add``1(``0,System.Collections.Generic.IEqualityComparer{``0}) -M:System.HashCode.AddBytes(System.ReadOnlySpan{System.Byte}) -M:System.HashCode.Combine``1(``0) -M:System.HashCode.Combine``2(``0,``1) -M:System.HashCode.Combine``3(``0,``1,``2) -M:System.HashCode.Combine``4(``0,``1,``2,``3) -M:System.HashCode.Combine``5(``0,``1,``2,``3,``4) -M:System.HashCode.Combine``6(``0,``1,``2,``3,``4,``5) -M:System.HashCode.Combine``7(``0,``1,``2,``3,``4,``5,``6) -M:System.HashCode.Combine``8(``0,``1,``2,``3,``4,``5,``6,``7) -M:System.HashCode.Equals(System.Object) -M:System.HashCode.GetHashCode -M:System.HashCode.ToHashCode -M:System.HttpStyleUriParser.#ctor -M:System.IAsyncDisposable.DisposeAsync -M:System.IAsyncResult.get_AsyncState -M:System.IAsyncResult.get_AsyncWaitHandle -M:System.IAsyncResult.get_CompletedSynchronously -M:System.IAsyncResult.get_IsCompleted -M:System.ICloneable.Clone -M:System.IComparable.CompareTo(System.Object) -M:System.IComparable`1.CompareTo(`0) -M:System.IConvertible.GetTypeCode -M:System.IConvertible.ToBoolean(System.IFormatProvider) -M:System.IConvertible.ToByte(System.IFormatProvider) -M:System.IConvertible.ToChar(System.IFormatProvider) -M:System.IConvertible.ToDateTime(System.IFormatProvider) -M:System.IConvertible.ToDecimal(System.IFormatProvider) -M:System.IConvertible.ToDouble(System.IFormatProvider) -M:System.IConvertible.ToInt16(System.IFormatProvider) -M:System.IConvertible.ToInt32(System.IFormatProvider) -M:System.IConvertible.ToInt64(System.IFormatProvider) -M:System.IConvertible.ToSByte(System.IFormatProvider) -M:System.IConvertible.ToSingle(System.IFormatProvider) -M:System.IConvertible.ToString(System.IFormatProvider) -M:System.IConvertible.ToType(System.Type,System.IFormatProvider) -M:System.IConvertible.ToUInt16(System.IFormatProvider) -M:System.IConvertible.ToUInt32(System.IFormatProvider) -M:System.IConvertible.ToUInt64(System.IFormatProvider) -M:System.ICustomFormatter.Format(System.String,System.Object,System.IFormatProvider) -M:System.IDisposable.Dispose -M:System.IEquatable`1.Equals(`0) -M:System.IFormatProvider.GetFormat(System.Type) -M:System.IFormattable.ToString(System.String,System.IFormatProvider) -M:System.Index.#ctor(System.Int32,System.Boolean) -M:System.Index.Equals(System.Index) -M:System.Index.Equals(System.Object) -M:System.Index.FromEnd(System.Int32) -M:System.Index.FromStart(System.Int32) -M:System.Index.get_End -M:System.Index.get_IsFromEnd -M:System.Index.get_Start -M:System.Index.get_Value -M:System.Index.GetHashCode -M:System.Index.GetOffset(System.Int32) -M:System.Index.op_Implicit(System.Int32)~System.Index -M:System.Index.ToString -M:System.IndexOutOfRangeException.#ctor -M:System.IndexOutOfRangeException.#ctor(System.String) -M:System.IndexOutOfRangeException.#ctor(System.String,System.Exception) -M:System.InsufficientExecutionStackException.#ctor -M:System.InsufficientExecutionStackException.#ctor(System.String) -M:System.InsufficientExecutionStackException.#ctor(System.String,System.Exception) -M:System.InsufficientMemoryException.#ctor -M:System.InsufficientMemoryException.#ctor(System.String) -M:System.InsufficientMemoryException.#ctor(System.String,System.Exception) -M:System.Int128.#ctor(System.UInt64,System.UInt64) -M:System.Int128.Abs(System.Int128) -M:System.Int128.Clamp(System.Int128,System.Int128,System.Int128) -M:System.Int128.CompareTo(System.Int128) -M:System.Int128.CompareTo(System.Object) -M:System.Int128.CopySign(System.Int128,System.Int128) -M:System.Int128.CreateChecked``1(``0) -M:System.Int128.CreateSaturating``1(``0) -M:System.Int128.CreateTruncating``1(``0) -M:System.Int128.DivRem(System.Int128,System.Int128) -M:System.Int128.Equals(System.Int128) -M:System.Int128.Equals(System.Object) -M:System.Int128.get_MaxValue -M:System.Int128.get_MinValue -M:System.Int128.get_NegativeOne -M:System.Int128.get_One -M:System.Int128.get_Zero -M:System.Int128.GetHashCode -M:System.Int128.IsEvenInteger(System.Int128) -M:System.Int128.IsNegative(System.Int128) -M:System.Int128.IsOddInteger(System.Int128) -M:System.Int128.IsPositive(System.Int128) -M:System.Int128.IsPow2(System.Int128) -M:System.Int128.LeadingZeroCount(System.Int128) -M:System.Int128.Log2(System.Int128) -M:System.Int128.Max(System.Int128,System.Int128) -M:System.Int128.MaxMagnitude(System.Int128,System.Int128) -M:System.Int128.Min(System.Int128,System.Int128) -M:System.Int128.MinMagnitude(System.Int128,System.Int128) -M:System.Int128.op_Addition(System.Int128,System.Int128) -M:System.Int128.op_BitwiseAnd(System.Int128,System.Int128) -M:System.Int128.op_BitwiseOr(System.Int128,System.Int128) -M:System.Int128.op_CheckedAddition(System.Int128,System.Int128) -M:System.Int128.op_CheckedDecrement(System.Int128) -M:System.Int128.op_CheckedDivision(System.Int128,System.Int128) -M:System.Int128.op_CheckedExplicit(System.Double)~System.Int128 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.Byte -M:System.Int128.op_CheckedExplicit(System.Int128)~System.Char -M:System.Int128.op_CheckedExplicit(System.Int128)~System.Int16 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.Int32 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.Int64 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.IntPtr -M:System.Int128.op_CheckedExplicit(System.Int128)~System.SByte -M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt128 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt16 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt32 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.UInt64 -M:System.Int128.op_CheckedExplicit(System.Int128)~System.UIntPtr -M:System.Int128.op_CheckedExplicit(System.Single)~System.Int128 -M:System.Int128.op_CheckedIncrement(System.Int128) -M:System.Int128.op_CheckedMultiply(System.Int128,System.Int128) -M:System.Int128.op_CheckedSubtraction(System.Int128,System.Int128) -M:System.Int128.op_CheckedUnaryNegation(System.Int128) -M:System.Int128.op_Decrement(System.Int128) -M:System.Int128.op_Division(System.Int128,System.Int128) -M:System.Int128.op_Equality(System.Int128,System.Int128) -M:System.Int128.op_ExclusiveOr(System.Int128,System.Int128) -M:System.Int128.op_Explicit(System.Decimal)~System.Int128 -M:System.Int128.op_Explicit(System.Double)~System.Int128 -M:System.Int128.op_Explicit(System.Int128)~System.Byte -M:System.Int128.op_Explicit(System.Int128)~System.Char -M:System.Int128.op_Explicit(System.Int128)~System.Decimal -M:System.Int128.op_Explicit(System.Int128)~System.Double -M:System.Int128.op_Explicit(System.Int128)~System.Half -M:System.Int128.op_Explicit(System.Int128)~System.Int16 -M:System.Int128.op_Explicit(System.Int128)~System.Int32 -M:System.Int128.op_Explicit(System.Int128)~System.Int64 -M:System.Int128.op_Explicit(System.Int128)~System.IntPtr -M:System.Int128.op_Explicit(System.Int128)~System.SByte -M:System.Int128.op_Explicit(System.Int128)~System.Single -M:System.Int128.op_Explicit(System.Int128)~System.UInt128 -M:System.Int128.op_Explicit(System.Int128)~System.UInt16 -M:System.Int128.op_Explicit(System.Int128)~System.UInt32 -M:System.Int128.op_Explicit(System.Int128)~System.UInt64 -M:System.Int128.op_Explicit(System.Int128)~System.UIntPtr -M:System.Int128.op_Explicit(System.Single)~System.Int128 -M:System.Int128.op_GreaterThan(System.Int128,System.Int128) -M:System.Int128.op_GreaterThanOrEqual(System.Int128,System.Int128) -M:System.Int128.op_Implicit(System.Byte)~System.Int128 -M:System.Int128.op_Implicit(System.Char)~System.Int128 -M:System.Int128.op_Implicit(System.Int16)~System.Int128 -M:System.Int128.op_Implicit(System.Int32)~System.Int128 -M:System.Int128.op_Implicit(System.Int64)~System.Int128 -M:System.Int128.op_Implicit(System.IntPtr)~System.Int128 -M:System.Int128.op_Implicit(System.SByte)~System.Int128 -M:System.Int128.op_Implicit(System.UInt16)~System.Int128 -M:System.Int128.op_Implicit(System.UInt32)~System.Int128 -M:System.Int128.op_Implicit(System.UInt64)~System.Int128 -M:System.Int128.op_Implicit(System.UIntPtr)~System.Int128 -M:System.Int128.op_Increment(System.Int128) -M:System.Int128.op_Inequality(System.Int128,System.Int128) -M:System.Int128.op_LeftShift(System.Int128,System.Int32) -M:System.Int128.op_LessThan(System.Int128,System.Int128) -M:System.Int128.op_LessThanOrEqual(System.Int128,System.Int128) -M:System.Int128.op_Modulus(System.Int128,System.Int128) -M:System.Int128.op_Multiply(System.Int128,System.Int128) -M:System.Int128.op_OnesComplement(System.Int128) -M:System.Int128.op_RightShift(System.Int128,System.Int32) -M:System.Int128.op_Subtraction(System.Int128,System.Int128) -M:System.Int128.op_UnaryNegation(System.Int128) -M:System.Int128.op_UnaryPlus(System.Int128) -M:System.Int128.op_UnsignedRightShift(System.Int128,System.Int32) -M:System.Int128.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int128.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Int128.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int128.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int128.Parse(System.String) -M:System.Int128.Parse(System.String,System.Globalization.NumberStyles) -M:System.Int128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int128.Parse(System.String,System.IFormatProvider) -M:System.Int128.PopCount(System.Int128) -M:System.Int128.RotateLeft(System.Int128,System.Int32) -M:System.Int128.RotateRight(System.Int128,System.Int32) -M:System.Int128.Sign(System.Int128) -M:System.Int128.ToString -M:System.Int128.ToString(System.IFormatProvider) -M:System.Int128.ToString(System.String) -M:System.Int128.ToString(System.String,System.IFormatProvider) -M:System.Int128.TrailingZeroCount(System.Int128) -M:System.Int128.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int128.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) -M:System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int128@) -M:System.Int128.TryParse(System.ReadOnlySpan{System.Byte},System.Int128@) -M:System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) -M:System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int128@) -M:System.Int128.TryParse(System.ReadOnlySpan{System.Char},System.Int128@) -M:System.Int128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int128@) -M:System.Int128.TryParse(System.String,System.IFormatProvider,System.Int128@) -M:System.Int128.TryParse(System.String,System.Int128@) -M:System.Int16.Abs(System.Int16) -M:System.Int16.Clamp(System.Int16,System.Int16,System.Int16) -M:System.Int16.CompareTo(System.Int16) -M:System.Int16.CompareTo(System.Object) -M:System.Int16.CopySign(System.Int16,System.Int16) -M:System.Int16.CreateChecked``1(``0) -M:System.Int16.CreateSaturating``1(``0) -M:System.Int16.CreateTruncating``1(``0) -M:System.Int16.DivRem(System.Int16,System.Int16) -M:System.Int16.Equals(System.Int16) -M:System.Int16.Equals(System.Object) -M:System.Int16.GetHashCode -M:System.Int16.GetTypeCode -M:System.Int16.IsEvenInteger(System.Int16) -M:System.Int16.IsNegative(System.Int16) -M:System.Int16.IsOddInteger(System.Int16) -M:System.Int16.IsPositive(System.Int16) -M:System.Int16.IsPow2(System.Int16) -M:System.Int16.LeadingZeroCount(System.Int16) -M:System.Int16.Log2(System.Int16) -M:System.Int16.Max(System.Int16,System.Int16) -M:System.Int16.MaxMagnitude(System.Int16,System.Int16) -M:System.Int16.Min(System.Int16,System.Int16) -M:System.Int16.MinMagnitude(System.Int16,System.Int16) -M:System.Int16.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int16.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Int16.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int16.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int16.Parse(System.String) -M:System.Int16.Parse(System.String,System.Globalization.NumberStyles) -M:System.Int16.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int16.Parse(System.String,System.IFormatProvider) -M:System.Int16.PopCount(System.Int16) -M:System.Int16.RotateLeft(System.Int16,System.Int32) -M:System.Int16.RotateRight(System.Int16,System.Int32) -M:System.Int16.Sign(System.Int16) -M:System.Int16.ToString -M:System.Int16.ToString(System.IFormatProvider) -M:System.Int16.ToString(System.String) -M:System.Int16.ToString(System.String,System.IFormatProvider) -M:System.Int16.TrailingZeroCount(System.Int16) -M:System.Int16.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int16.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) -M:System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int16@) -M:System.Int16.TryParse(System.ReadOnlySpan{System.Byte},System.Int16@) -M:System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) -M:System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int16@) -M:System.Int16.TryParse(System.ReadOnlySpan{System.Char},System.Int16@) -M:System.Int16.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@) -M:System.Int16.TryParse(System.String,System.IFormatProvider,System.Int16@) -M:System.Int16.TryParse(System.String,System.Int16@) -M:System.Int32.Abs(System.Int32) -M:System.Int32.Clamp(System.Int32,System.Int32,System.Int32) -M:System.Int32.CompareTo(System.Int32) -M:System.Int32.CompareTo(System.Object) -M:System.Int32.CopySign(System.Int32,System.Int32) -M:System.Int32.CreateChecked``1(``0) -M:System.Int32.CreateSaturating``1(``0) -M:System.Int32.CreateTruncating``1(``0) -M:System.Int32.DivRem(System.Int32,System.Int32) -M:System.Int32.Equals(System.Int32) -M:System.Int32.Equals(System.Object) -M:System.Int32.GetHashCode -M:System.Int32.GetTypeCode -M:System.Int32.IsEvenInteger(System.Int32) -M:System.Int32.IsNegative(System.Int32) -M:System.Int32.IsOddInteger(System.Int32) -M:System.Int32.IsPositive(System.Int32) -M:System.Int32.IsPow2(System.Int32) -M:System.Int32.LeadingZeroCount(System.Int32) -M:System.Int32.Log2(System.Int32) -M:System.Int32.Max(System.Int32,System.Int32) -M:System.Int32.MaxMagnitude(System.Int32,System.Int32) -M:System.Int32.Min(System.Int32,System.Int32) -M:System.Int32.MinMagnitude(System.Int32,System.Int32) -M:System.Int32.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int32.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Int32.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int32.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int32.Parse(System.String) -M:System.Int32.Parse(System.String,System.Globalization.NumberStyles) -M:System.Int32.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int32.Parse(System.String,System.IFormatProvider) -M:System.Int32.PopCount(System.Int32) -M:System.Int32.RotateLeft(System.Int32,System.Int32) -M:System.Int32.RotateRight(System.Int32,System.Int32) -M:System.Int32.Sign(System.Int32) -M:System.Int32.ToString -M:System.Int32.ToString(System.IFormatProvider) -M:System.Int32.ToString(System.String) -M:System.Int32.ToString(System.String,System.IFormatProvider) -M:System.Int32.TrailingZeroCount(System.Int32) -M:System.Int32.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int32.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) -M:System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int32@) -M:System.Int32.TryParse(System.ReadOnlySpan{System.Byte},System.Int32@) -M:System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) -M:System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int32@) -M:System.Int32.TryParse(System.ReadOnlySpan{System.Char},System.Int32@) -M:System.Int32.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@) -M:System.Int32.TryParse(System.String,System.IFormatProvider,System.Int32@) -M:System.Int32.TryParse(System.String,System.Int32@) -M:System.Int64.Abs(System.Int64) -M:System.Int64.Clamp(System.Int64,System.Int64,System.Int64) -M:System.Int64.CompareTo(System.Int64) -M:System.Int64.CompareTo(System.Object) -M:System.Int64.CopySign(System.Int64,System.Int64) -M:System.Int64.CreateChecked``1(``0) -M:System.Int64.CreateSaturating``1(``0) -M:System.Int64.CreateTruncating``1(``0) -M:System.Int64.DivRem(System.Int64,System.Int64) -M:System.Int64.Equals(System.Int64) -M:System.Int64.Equals(System.Object) -M:System.Int64.GetHashCode -M:System.Int64.GetTypeCode -M:System.Int64.IsEvenInteger(System.Int64) -M:System.Int64.IsNegative(System.Int64) -M:System.Int64.IsOddInteger(System.Int64) -M:System.Int64.IsPositive(System.Int64) -M:System.Int64.IsPow2(System.Int64) -M:System.Int64.LeadingZeroCount(System.Int64) -M:System.Int64.Log2(System.Int64) -M:System.Int64.Max(System.Int64,System.Int64) -M:System.Int64.MaxMagnitude(System.Int64,System.Int64) -M:System.Int64.Min(System.Int64,System.Int64) -M:System.Int64.MinMagnitude(System.Int64,System.Int64) -M:System.Int64.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int64.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Int64.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int64.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int64.Parse(System.String) -M:System.Int64.Parse(System.String,System.Globalization.NumberStyles) -M:System.Int64.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Int64.Parse(System.String,System.IFormatProvider) -M:System.Int64.PopCount(System.Int64) -M:System.Int64.RotateLeft(System.Int64,System.Int32) -M:System.Int64.RotateRight(System.Int64,System.Int32) -M:System.Int64.Sign(System.Int64) -M:System.Int64.ToString -M:System.Int64.ToString(System.IFormatProvider) -M:System.Int64.ToString(System.String) -M:System.Int64.ToString(System.String,System.IFormatProvider) -M:System.Int64.TrailingZeroCount(System.Int64) -M:System.Int64.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int64.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) -M:System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Int64@) -M:System.Int64.TryParse(System.ReadOnlySpan{System.Byte},System.Int64@) -M:System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) -M:System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Int64@) -M:System.Int64.TryParse(System.ReadOnlySpan{System.Char},System.Int64@) -M:System.Int64.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@) -M:System.Int64.TryParse(System.String,System.IFormatProvider,System.Int64@) -M:System.Int64.TryParse(System.String,System.Int64@) -M:System.IntPtr.#ctor(System.Int32) -M:System.IntPtr.#ctor(System.Int64) -M:System.IntPtr.#ctor(System.Void*) -M:System.IntPtr.Abs(System.IntPtr) -M:System.IntPtr.Add(System.IntPtr,System.Int32) -M:System.IntPtr.Clamp(System.IntPtr,System.IntPtr,System.IntPtr) -M:System.IntPtr.CompareTo(System.IntPtr) -M:System.IntPtr.CompareTo(System.Object) -M:System.IntPtr.CopySign(System.IntPtr,System.IntPtr) -M:System.IntPtr.CreateChecked``1(``0) -M:System.IntPtr.CreateSaturating``1(``0) -M:System.IntPtr.CreateTruncating``1(``0) -M:System.IntPtr.DivRem(System.IntPtr,System.IntPtr) -M:System.IntPtr.Equals(System.IntPtr) -M:System.IntPtr.Equals(System.Object) -M:System.IntPtr.get_MaxValue -M:System.IntPtr.get_MinValue -M:System.IntPtr.get_Size -M:System.IntPtr.GetHashCode -M:System.IntPtr.IsEvenInteger(System.IntPtr) -M:System.IntPtr.IsNegative(System.IntPtr) -M:System.IntPtr.IsOddInteger(System.IntPtr) -M:System.IntPtr.IsPositive(System.IntPtr) -M:System.IntPtr.IsPow2(System.IntPtr) -M:System.IntPtr.LeadingZeroCount(System.IntPtr) -M:System.IntPtr.Log2(System.IntPtr) -M:System.IntPtr.Max(System.IntPtr,System.IntPtr) -M:System.IntPtr.MaxMagnitude(System.IntPtr,System.IntPtr) -M:System.IntPtr.Min(System.IntPtr,System.IntPtr) -M:System.IntPtr.MinMagnitude(System.IntPtr,System.IntPtr) -M:System.IntPtr.op_Addition(System.IntPtr,System.Int32) -M:System.IntPtr.op_Equality(System.IntPtr,System.IntPtr) -M:System.IntPtr.op_Explicit(System.Int32)~System.IntPtr -M:System.IntPtr.op_Explicit(System.Int64)~System.IntPtr -M:System.IntPtr.op_Explicit(System.IntPtr)~System.Int32 -M:System.IntPtr.op_Explicit(System.IntPtr)~System.Int64 -M:System.IntPtr.op_Explicit(System.IntPtr)~System.Void* -M:System.IntPtr.op_Explicit(System.Void*)~System.IntPtr -M:System.IntPtr.op_Inequality(System.IntPtr,System.IntPtr) -M:System.IntPtr.op_Subtraction(System.IntPtr,System.Int32) -M:System.IntPtr.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.IntPtr.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.IntPtr.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.IntPtr.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.IntPtr.Parse(System.String) -M:System.IntPtr.Parse(System.String,System.Globalization.NumberStyles) -M:System.IntPtr.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.IntPtr.Parse(System.String,System.IFormatProvider) -M:System.IntPtr.PopCount(System.IntPtr) -M:System.IntPtr.RotateLeft(System.IntPtr,System.Int32) -M:System.IntPtr.RotateRight(System.IntPtr,System.Int32) -M:System.IntPtr.Sign(System.IntPtr) -M:System.IntPtr.Subtract(System.IntPtr,System.Int32) -M:System.IntPtr.ToInt32 -M:System.IntPtr.ToInt64 -M:System.IntPtr.ToPointer -M:System.IntPtr.ToString -M:System.IntPtr.ToString(System.IFormatProvider) -M:System.IntPtr.ToString(System.String) -M:System.IntPtr.ToString(System.String,System.IFormatProvider) -M:System.IntPtr.TrailingZeroCount(System.IntPtr) -M:System.IntPtr.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.IntPtr.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) -M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.IntPtr@) -M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IntPtr@) -M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) -M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.IntPtr@) -M:System.IntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IntPtr@) -M:System.IntPtr.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.IntPtr@) -M:System.IntPtr.TryParse(System.String,System.IFormatProvider,System.IntPtr@) -M:System.IntPtr.TryParse(System.String,System.IntPtr@) -M:System.InvalidCastException.#ctor -M:System.InvalidCastException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.InvalidCastException.#ctor(System.String) -M:System.InvalidCastException.#ctor(System.String,System.Exception) -M:System.InvalidCastException.#ctor(System.String,System.Int32) -M:System.InvalidOperationException.#ctor -M:System.InvalidOperationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.InvalidOperationException.#ctor(System.String) -M:System.InvalidOperationException.#ctor(System.String,System.Exception) -M:System.InvalidProgramException.#ctor -M:System.InvalidProgramException.#ctor(System.String) -M:System.InvalidProgramException.#ctor(System.String,System.Exception) -M:System.InvalidTimeZoneException.#ctor -M:System.InvalidTimeZoneException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.InvalidTimeZoneException.#ctor(System.String) -M:System.InvalidTimeZoneException.#ctor(System.String,System.Exception) -M:System.IObservable`1.Subscribe(System.IObserver{`0}) -M:System.IObserver`1.OnCompleted -M:System.IObserver`1.OnError(System.Exception) -M:System.IObserver`1.OnNext(`0) -M:System.IParsable`1.Parse(System.String,System.IFormatProvider) -M:System.IParsable`1.TryParse(System.String,System.IFormatProvider,`0@) -M:System.IProgress`1.Report(`0) -M:System.ISpanFormattable.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.ISpanParsable`1.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.ISpanParsable`1.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,`0@) -M:System.IUtf8SpanFormattable.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.IUtf8SpanParsable`1.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.IUtf8SpanParsable`1.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,`0@) -M:System.Lazy`1.#ctor -M:System.Lazy`1.#ctor(`0) -M:System.Lazy`1.#ctor(System.Boolean) -M:System.Lazy`1.#ctor(System.Func{`0}) -M:System.Lazy`1.#ctor(System.Func{`0},System.Boolean) -M:System.Lazy`1.#ctor(System.Func{`0},System.Threading.LazyThreadSafetyMode) -M:System.Lazy`1.#ctor(System.Threading.LazyThreadSafetyMode) -M:System.Lazy`1.get_IsValueCreated -M:System.Lazy`1.get_Value -M:System.Lazy`1.ToString -M:System.Lazy`2.#ctor(`1) -M:System.Lazy`2.#ctor(`1,System.Boolean) -M:System.Lazy`2.#ctor(`1,System.Threading.LazyThreadSafetyMode) -M:System.Lazy`2.#ctor(System.Func{`0},`1) -M:System.Lazy`2.#ctor(System.Func{`0},`1,System.Boolean) -M:System.Lazy`2.#ctor(System.Func{`0},`1,System.Threading.LazyThreadSafetyMode) -M:System.Lazy`2.get_Metadata -M:System.LdapStyleUriParser.#ctor -M:System.Math.Abs(System.Decimal) -M:System.Math.Abs(System.Double) -M:System.Math.Abs(System.Int16) -M:System.Math.Abs(System.Int32) -M:System.Math.Abs(System.Int64) -M:System.Math.Abs(System.IntPtr) -M:System.Math.Abs(System.SByte) -M:System.Math.Abs(System.Single) -M:System.Math.Acos(System.Double) -M:System.Math.Acosh(System.Double) -M:System.Math.Asin(System.Double) -M:System.Math.Asinh(System.Double) -M:System.Math.Atan(System.Double) -M:System.Math.Atan2(System.Double,System.Double) -M:System.Math.Atanh(System.Double) -M:System.Math.BigMul(System.Int32,System.Int32) -M:System.Math.BigMul(System.Int64,System.Int64,System.Int64@) -M:System.Math.BigMul(System.UInt64,System.UInt64,System.UInt64@) -M:System.Math.BitDecrement(System.Double) -M:System.Math.BitIncrement(System.Double) -M:System.Math.Cbrt(System.Double) -M:System.Math.Ceiling(System.Decimal) -M:System.Math.Ceiling(System.Double) -M:System.Math.Clamp(System.Byte,System.Byte,System.Byte) -M:System.Math.Clamp(System.Decimal,System.Decimal,System.Decimal) -M:System.Math.Clamp(System.Double,System.Double,System.Double) -M:System.Math.Clamp(System.Int16,System.Int16,System.Int16) -M:System.Math.Clamp(System.Int32,System.Int32,System.Int32) -M:System.Math.Clamp(System.Int64,System.Int64,System.Int64) -M:System.Math.Clamp(System.IntPtr,System.IntPtr,System.IntPtr) -M:System.Math.Clamp(System.SByte,System.SByte,System.SByte) -M:System.Math.Clamp(System.Single,System.Single,System.Single) -M:System.Math.Clamp(System.UInt16,System.UInt16,System.UInt16) -M:System.Math.Clamp(System.UInt32,System.UInt32,System.UInt32) -M:System.Math.Clamp(System.UInt64,System.UInt64,System.UInt64) -M:System.Math.Clamp(System.UIntPtr,System.UIntPtr,System.UIntPtr) -M:System.Math.CopySign(System.Double,System.Double) -M:System.Math.Cos(System.Double) -M:System.Math.Cosh(System.Double) -M:System.Math.DivRem(System.Byte,System.Byte) -M:System.Math.DivRem(System.Int16,System.Int16) -M:System.Math.DivRem(System.Int32,System.Int32) -M:System.Math.DivRem(System.Int32,System.Int32,System.Int32@) -M:System.Math.DivRem(System.Int64,System.Int64) -M:System.Math.DivRem(System.Int64,System.Int64,System.Int64@) -M:System.Math.DivRem(System.IntPtr,System.IntPtr) -M:System.Math.DivRem(System.SByte,System.SByte) -M:System.Math.DivRem(System.UInt16,System.UInt16) -M:System.Math.DivRem(System.UInt32,System.UInt32) -M:System.Math.DivRem(System.UInt64,System.UInt64) -M:System.Math.DivRem(System.UIntPtr,System.UIntPtr) -M:System.Math.Exp(System.Double) -M:System.Math.Floor(System.Decimal) -M:System.Math.Floor(System.Double) -M:System.Math.FusedMultiplyAdd(System.Double,System.Double,System.Double) -M:System.Math.IEEERemainder(System.Double,System.Double) -M:System.Math.ILogB(System.Double) -M:System.Math.Log(System.Double) -M:System.Math.Log(System.Double,System.Double) -M:System.Math.Log10(System.Double) -M:System.Math.Log2(System.Double) -M:System.Math.Max(System.Byte,System.Byte) -M:System.Math.Max(System.Decimal,System.Decimal) -M:System.Math.Max(System.Double,System.Double) -M:System.Math.Max(System.Int16,System.Int16) -M:System.Math.Max(System.Int32,System.Int32) -M:System.Math.Max(System.Int64,System.Int64) -M:System.Math.Max(System.IntPtr,System.IntPtr) -M:System.Math.Max(System.SByte,System.SByte) -M:System.Math.Max(System.Single,System.Single) -M:System.Math.Max(System.UInt16,System.UInt16) -M:System.Math.Max(System.UInt32,System.UInt32) -M:System.Math.Max(System.UInt64,System.UInt64) -M:System.Math.Max(System.UIntPtr,System.UIntPtr) -M:System.Math.MaxMagnitude(System.Double,System.Double) -M:System.Math.Min(System.Byte,System.Byte) -M:System.Math.Min(System.Decimal,System.Decimal) -M:System.Math.Min(System.Double,System.Double) -M:System.Math.Min(System.Int16,System.Int16) -M:System.Math.Min(System.Int32,System.Int32) -M:System.Math.Min(System.Int64,System.Int64) -M:System.Math.Min(System.IntPtr,System.IntPtr) -M:System.Math.Min(System.SByte,System.SByte) -M:System.Math.Min(System.Single,System.Single) -M:System.Math.Min(System.UInt16,System.UInt16) -M:System.Math.Min(System.UInt32,System.UInt32) -M:System.Math.Min(System.UInt64,System.UInt64) -M:System.Math.Min(System.UIntPtr,System.UIntPtr) -M:System.Math.MinMagnitude(System.Double,System.Double) -M:System.Math.Pow(System.Double,System.Double) -M:System.Math.ReciprocalEstimate(System.Double) -M:System.Math.ReciprocalSqrtEstimate(System.Double) -M:System.Math.Round(System.Decimal) -M:System.Math.Round(System.Decimal,System.Int32) -M:System.Math.Round(System.Decimal,System.Int32,System.MidpointRounding) -M:System.Math.Round(System.Decimal,System.MidpointRounding) -M:System.Math.Round(System.Double) -M:System.Math.Round(System.Double,System.Int32) -M:System.Math.Round(System.Double,System.Int32,System.MidpointRounding) -M:System.Math.Round(System.Double,System.MidpointRounding) -M:System.Math.ScaleB(System.Double,System.Int32) -M:System.Math.Sign(System.Decimal) -M:System.Math.Sign(System.Double) -M:System.Math.Sign(System.Int16) -M:System.Math.Sign(System.Int32) -M:System.Math.Sign(System.Int64) -M:System.Math.Sign(System.IntPtr) -M:System.Math.Sign(System.SByte) -M:System.Math.Sign(System.Single) -M:System.Math.Sin(System.Double) -M:System.Math.SinCos(System.Double) -M:System.Math.Sinh(System.Double) -M:System.Math.Sqrt(System.Double) -M:System.Math.Tan(System.Double) -M:System.Math.Tanh(System.Double) -M:System.Math.Truncate(System.Decimal) -M:System.Math.Truncate(System.Double) -M:System.MathF.Abs(System.Single) -M:System.MathF.Acos(System.Single) -M:System.MathF.Acosh(System.Single) -M:System.MathF.Asin(System.Single) -M:System.MathF.Asinh(System.Single) -M:System.MathF.Atan(System.Single) -M:System.MathF.Atan2(System.Single,System.Single) -M:System.MathF.Atanh(System.Single) -M:System.MathF.BitDecrement(System.Single) -M:System.MathF.BitIncrement(System.Single) -M:System.MathF.Cbrt(System.Single) -M:System.MathF.Ceiling(System.Single) -M:System.MathF.CopySign(System.Single,System.Single) -M:System.MathF.Cos(System.Single) -M:System.MathF.Cosh(System.Single) -M:System.MathF.Exp(System.Single) -M:System.MathF.Floor(System.Single) -M:System.MathF.FusedMultiplyAdd(System.Single,System.Single,System.Single) -M:System.MathF.IEEERemainder(System.Single,System.Single) -M:System.MathF.ILogB(System.Single) -M:System.MathF.Log(System.Single) -M:System.MathF.Log(System.Single,System.Single) -M:System.MathF.Log10(System.Single) -M:System.MathF.Log2(System.Single) -M:System.MathF.Max(System.Single,System.Single) -M:System.MathF.MaxMagnitude(System.Single,System.Single) -M:System.MathF.Min(System.Single,System.Single) -M:System.MathF.MinMagnitude(System.Single,System.Single) -M:System.MathF.Pow(System.Single,System.Single) -M:System.MathF.ReciprocalEstimate(System.Single) -M:System.MathF.ReciprocalSqrtEstimate(System.Single) -M:System.MathF.Round(System.Single) -M:System.MathF.Round(System.Single,System.Int32) -M:System.MathF.Round(System.Single,System.Int32,System.MidpointRounding) -M:System.MathF.Round(System.Single,System.MidpointRounding) -M:System.MathF.ScaleB(System.Single,System.Int32) -M:System.MathF.Sign(System.Single) -M:System.MathF.Sin(System.Single) -M:System.MathF.SinCos(System.Single) -M:System.MathF.Sinh(System.Single) -M:System.MathF.Sqrt(System.Single) -M:System.MathF.Tan(System.Single) -M:System.MathF.Tanh(System.Single) -M:System.MathF.Truncate(System.Single) -M:System.MemberAccessException.#ctor -M:System.MemberAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MemberAccessException.#ctor(System.String) -M:System.MemberAccessException.#ctor(System.String,System.Exception) -M:System.Memory`1.#ctor(`0[]) -M:System.Memory`1.#ctor(`0[],System.Int32,System.Int32) -M:System.Memory`1.CopyTo(System.Memory{`0}) -M:System.Memory`1.Equals(System.Memory{`0}) -M:System.Memory`1.Equals(System.Object) -M:System.Memory`1.get_Empty -M:System.Memory`1.get_IsEmpty -M:System.Memory`1.get_Length -M:System.Memory`1.get_Span -M:System.Memory`1.GetHashCode -M:System.Memory`1.op_Implicit(`0[])~System.Memory{`0} -M:System.Memory`1.op_Implicit(System.ArraySegment{`0})~System.Memory{`0} -M:System.Memory`1.op_Implicit(System.Memory{`0})~System.ReadOnlyMemory{`0} -M:System.Memory`1.Pin -M:System.Memory`1.Slice(System.Int32) -M:System.Memory`1.Slice(System.Int32,System.Int32) -M:System.Memory`1.ToArray -M:System.Memory`1.ToString -M:System.Memory`1.TryCopyTo(System.Memory{`0}) -M:System.MethodAccessException.#ctor -M:System.MethodAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MethodAccessException.#ctor(System.String) -M:System.MethodAccessException.#ctor(System.String,System.Exception) -M:System.MissingFieldException.#ctor -M:System.MissingFieldException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MissingFieldException.#ctor(System.String) -M:System.MissingFieldException.#ctor(System.String,System.Exception) -M:System.MissingFieldException.#ctor(System.String,System.String) -M:System.MissingFieldException.get_Message -M:System.MissingMemberException.#ctor -M:System.MissingMemberException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MissingMemberException.#ctor(System.String) -M:System.MissingMemberException.#ctor(System.String,System.Exception) -M:System.MissingMemberException.#ctor(System.String,System.String) -M:System.MissingMemberException.get_Message -M:System.MissingMemberException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MissingMethodException.#ctor -M:System.MissingMethodException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MissingMethodException.#ctor(System.String) -M:System.MissingMethodException.#ctor(System.String,System.Exception) -M:System.MissingMethodException.#ctor(System.String,System.String) -M:System.MissingMethodException.get_Message -M:System.ModuleHandle.Equals(System.ModuleHandle) -M:System.ModuleHandle.Equals(System.Object) -M:System.ModuleHandle.get_MDStreamVersion -M:System.ModuleHandle.GetHashCode -M:System.ModuleHandle.GetRuntimeFieldHandleFromMetadataToken(System.Int32) -M:System.ModuleHandle.GetRuntimeMethodHandleFromMetadataToken(System.Int32) -M:System.ModuleHandle.GetRuntimeTypeHandleFromMetadataToken(System.Int32) -M:System.ModuleHandle.op_Equality(System.ModuleHandle,System.ModuleHandle) -M:System.ModuleHandle.op_Inequality(System.ModuleHandle,System.ModuleHandle) -M:System.ModuleHandle.ResolveFieldHandle(System.Int32) -M:System.ModuleHandle.ResolveFieldHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[]) -M:System.ModuleHandle.ResolveMethodHandle(System.Int32) -M:System.ModuleHandle.ResolveMethodHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[]) -M:System.ModuleHandle.ResolveTypeHandle(System.Int32) -M:System.ModuleHandle.ResolveTypeHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[]) -M:System.MulticastDelegate.#ctor(System.Object,System.String) -M:System.MulticastDelegate.#ctor(System.Type,System.String) -M:System.MulticastDelegate.CombineImpl(System.Delegate) -M:System.MulticastDelegate.Equals(System.Object) -M:System.MulticastDelegate.GetHashCode -M:System.MulticastDelegate.GetInvocationList -M:System.MulticastDelegate.GetMethodImpl -M:System.MulticastDelegate.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.MulticastDelegate.op_Equality(System.MulticastDelegate,System.MulticastDelegate) -M:System.MulticastDelegate.op_Inequality(System.MulticastDelegate,System.MulticastDelegate) -M:System.MulticastDelegate.RemoveImpl(System.Delegate) -M:System.MulticastNotSupportedException.#ctor -M:System.MulticastNotSupportedException.#ctor(System.String) -M:System.MulticastNotSupportedException.#ctor(System.String,System.Exception) -M:System.NetPipeStyleUriParser.#ctor -M:System.NetTcpStyleUriParser.#ctor -M:System.NewsStyleUriParser.#ctor -M:System.NonSerializedAttribute.#ctor -M:System.NotFiniteNumberException.#ctor -M:System.NotFiniteNumberException.#ctor(System.Double) -M:System.NotFiniteNumberException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.NotFiniteNumberException.#ctor(System.String) -M:System.NotFiniteNumberException.#ctor(System.String,System.Double) -M:System.NotFiniteNumberException.#ctor(System.String,System.Double,System.Exception) -M:System.NotFiniteNumberException.#ctor(System.String,System.Exception) -M:System.NotFiniteNumberException.get_OffendingNumber -M:System.NotFiniteNumberException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.NotImplementedException.#ctor -M:System.NotImplementedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.NotImplementedException.#ctor(System.String) -M:System.NotImplementedException.#ctor(System.String,System.Exception) -M:System.NotSupportedException.#ctor -M:System.NotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.NotSupportedException.#ctor(System.String) -M:System.NotSupportedException.#ctor(System.String,System.Exception) -M:System.Nullable.Compare``1(System.Nullable{``0},System.Nullable{``0}) -M:System.Nullable.Equals``1(System.Nullable{``0},System.Nullable{``0}) -M:System.Nullable.GetUnderlyingType(System.Type) -M:System.Nullable.GetValueRefOrDefaultRef``1(System.Nullable{``0}@) -M:System.Nullable`1.#ctor(`0) -M:System.Nullable`1.Equals(System.Object) -M:System.Nullable`1.get_HasValue -M:System.Nullable`1.get_Value -M:System.Nullable`1.GetHashCode -M:System.Nullable`1.GetValueOrDefault -M:System.Nullable`1.GetValueOrDefault(`0) -M:System.Nullable`1.op_Explicit(System.Nullable{`0})~`0 -M:System.Nullable`1.op_Implicit(`0)~System.Nullable{`0} -M:System.Nullable`1.ToString -M:System.NullReferenceException.#ctor -M:System.NullReferenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.NullReferenceException.#ctor(System.String) -M:System.NullReferenceException.#ctor(System.String,System.Exception) -M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.Byte) -M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt16) -M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt32) -M:System.Numerics.BitOperations.Crc32C(System.UInt32,System.UInt64) -M:System.Numerics.BitOperations.IsPow2(System.Int32) -M:System.Numerics.BitOperations.IsPow2(System.Int64) -M:System.Numerics.BitOperations.IsPow2(System.IntPtr) -M:System.Numerics.BitOperations.IsPow2(System.UInt32) -M:System.Numerics.BitOperations.IsPow2(System.UInt64) -M:System.Numerics.BitOperations.IsPow2(System.UIntPtr) -M:System.Numerics.BitOperations.LeadingZeroCount(System.UInt32) -M:System.Numerics.BitOperations.LeadingZeroCount(System.UInt64) -M:System.Numerics.BitOperations.LeadingZeroCount(System.UIntPtr) -M:System.Numerics.BitOperations.Log2(System.UInt32) -M:System.Numerics.BitOperations.Log2(System.UInt64) -M:System.Numerics.BitOperations.Log2(System.UIntPtr) -M:System.Numerics.BitOperations.PopCount(System.UInt32) -M:System.Numerics.BitOperations.PopCount(System.UInt64) -M:System.Numerics.BitOperations.PopCount(System.UIntPtr) -M:System.Numerics.BitOperations.RotateLeft(System.UInt32,System.Int32) -M:System.Numerics.BitOperations.RotateLeft(System.UInt64,System.Int32) -M:System.Numerics.BitOperations.RotateLeft(System.UIntPtr,System.Int32) -M:System.Numerics.BitOperations.RotateRight(System.UInt32,System.Int32) -M:System.Numerics.BitOperations.RotateRight(System.UInt64,System.Int32) -M:System.Numerics.BitOperations.RotateRight(System.UIntPtr,System.Int32) -M:System.Numerics.BitOperations.RoundUpToPowerOf2(System.UInt32) -M:System.Numerics.BitOperations.RoundUpToPowerOf2(System.UInt64) -M:System.Numerics.BitOperations.RoundUpToPowerOf2(System.UIntPtr) -M:System.Numerics.BitOperations.TrailingZeroCount(System.Int32) -M:System.Numerics.BitOperations.TrailingZeroCount(System.Int64) -M:System.Numerics.BitOperations.TrailingZeroCount(System.IntPtr) -M:System.Numerics.BitOperations.TrailingZeroCount(System.UInt32) -M:System.Numerics.BitOperations.TrailingZeroCount(System.UInt64) -M:System.Numerics.BitOperations.TrailingZeroCount(System.UIntPtr) -M:System.Numerics.IAdditionOperators`3.op_Addition(`0,`1) -M:System.Numerics.IAdditionOperators`3.op_CheckedAddition(`0,`1) -M:System.Numerics.IAdditiveIdentity`2.get_AdditiveIdentity -M:System.Numerics.IBinaryInteger`1.DivRem(`0,`0) -M:System.Numerics.IBinaryInteger`1.GetByteCount -M:System.Numerics.IBinaryInteger`1.GetShortestBitLength -M:System.Numerics.IBinaryInteger`1.LeadingZeroCount(`0) -M:System.Numerics.IBinaryInteger`1.PopCount(`0) -M:System.Numerics.IBinaryInteger`1.ReadBigEndian(System.Byte[],System.Boolean) -M:System.Numerics.IBinaryInteger`1.ReadBigEndian(System.Byte[],System.Int32,System.Boolean) -M:System.Numerics.IBinaryInteger`1.ReadBigEndian(System.ReadOnlySpan{System.Byte},System.Boolean) -M:System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.Byte[],System.Boolean) -M:System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.Byte[],System.Int32,System.Boolean) -M:System.Numerics.IBinaryInteger`1.ReadLittleEndian(System.ReadOnlySpan{System.Byte},System.Boolean) -M:System.Numerics.IBinaryInteger`1.RotateLeft(`0,System.Int32) -M:System.Numerics.IBinaryInteger`1.RotateRight(`0,System.Int32) -M:System.Numerics.IBinaryInteger`1.TrailingZeroCount(`0) -M:System.Numerics.IBinaryInteger`1.TryReadBigEndian(System.ReadOnlySpan{System.Byte},System.Boolean,`0@) -M:System.Numerics.IBinaryInteger`1.TryReadLittleEndian(System.ReadOnlySpan{System.Byte},System.Boolean,`0@) -M:System.Numerics.IBinaryInteger`1.TryWriteBigEndian(System.Span{System.Byte},System.Int32@) -M:System.Numerics.IBinaryInteger`1.TryWriteLittleEndian(System.Span{System.Byte},System.Int32@) -M:System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Byte[]) -M:System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Byte[],System.Int32) -M:System.Numerics.IBinaryInteger`1.WriteBigEndian(System.Span{System.Byte}) -M:System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Byte[]) -M:System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Byte[],System.Int32) -M:System.Numerics.IBinaryInteger`1.WriteLittleEndian(System.Span{System.Byte}) -M:System.Numerics.IBinaryNumber`1.get_AllBitsSet -M:System.Numerics.IBinaryNumber`1.IsPow2(`0) -M:System.Numerics.IBinaryNumber`1.Log2(`0) -M:System.Numerics.IBitwiseOperators`3.op_BitwiseAnd(`0,`1) -M:System.Numerics.IBitwiseOperators`3.op_BitwiseOr(`0,`1) -M:System.Numerics.IBitwiseOperators`3.op_ExclusiveOr(`0,`1) -M:System.Numerics.IBitwiseOperators`3.op_OnesComplement(`0) -M:System.Numerics.IComparisonOperators`3.op_GreaterThan(`0,`1) -M:System.Numerics.IComparisonOperators`3.op_GreaterThanOrEqual(`0,`1) -M:System.Numerics.IComparisonOperators`3.op_LessThan(`0,`1) -M:System.Numerics.IComparisonOperators`3.op_LessThanOrEqual(`0,`1) -M:System.Numerics.IDecrementOperators`1.op_CheckedDecrement(`0) -M:System.Numerics.IDecrementOperators`1.op_Decrement(`0) -M:System.Numerics.IDivisionOperators`3.op_CheckedDivision(`0,`1) -M:System.Numerics.IDivisionOperators`3.op_Division(`0,`1) -M:System.Numerics.IEqualityOperators`3.op_Equality(`0,`1) -M:System.Numerics.IEqualityOperators`3.op_Inequality(`0,`1) -M:System.Numerics.IExponentialFunctions`1.Exp(`0) -M:System.Numerics.IExponentialFunctions`1.Exp10(`0) -M:System.Numerics.IExponentialFunctions`1.Exp10M1(`0) -M:System.Numerics.IExponentialFunctions`1.Exp2(`0) -M:System.Numerics.IExponentialFunctions`1.Exp2M1(`0) -M:System.Numerics.IExponentialFunctions`1.ExpM1(`0) -M:System.Numerics.IFloatingPoint`1.Ceiling(`0) -M:System.Numerics.IFloatingPoint`1.Floor(`0) -M:System.Numerics.IFloatingPoint`1.GetExponentByteCount -M:System.Numerics.IFloatingPoint`1.GetExponentShortestBitLength -M:System.Numerics.IFloatingPoint`1.GetSignificandBitLength -M:System.Numerics.IFloatingPoint`1.GetSignificandByteCount -M:System.Numerics.IFloatingPoint`1.Round(`0) -M:System.Numerics.IFloatingPoint`1.Round(`0,System.Int32) -M:System.Numerics.IFloatingPoint`1.Round(`0,System.Int32,System.MidpointRounding) -M:System.Numerics.IFloatingPoint`1.Round(`0,System.MidpointRounding) -M:System.Numerics.IFloatingPoint`1.Truncate(`0) -M:System.Numerics.IFloatingPoint`1.TryWriteExponentBigEndian(System.Span{System.Byte},System.Int32@) -M:System.Numerics.IFloatingPoint`1.TryWriteExponentLittleEndian(System.Span{System.Byte},System.Int32@) -M:System.Numerics.IFloatingPoint`1.TryWriteSignificandBigEndian(System.Span{System.Byte},System.Int32@) -M:System.Numerics.IFloatingPoint`1.TryWriteSignificandLittleEndian(System.Span{System.Byte},System.Int32@) -M:System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Byte[]) -M:System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Byte[],System.Int32) -M:System.Numerics.IFloatingPoint`1.WriteExponentBigEndian(System.Span{System.Byte}) -M:System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Byte[]) -M:System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Byte[],System.Int32) -M:System.Numerics.IFloatingPoint`1.WriteExponentLittleEndian(System.Span{System.Byte}) -M:System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Byte[]) -M:System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Byte[],System.Int32) -M:System.Numerics.IFloatingPoint`1.WriteSignificandBigEndian(System.Span{System.Byte}) -M:System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Byte[]) -M:System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Byte[],System.Int32) -M:System.Numerics.IFloatingPoint`1.WriteSignificandLittleEndian(System.Span{System.Byte}) -M:System.Numerics.IFloatingPointConstants`1.get_E -M:System.Numerics.IFloatingPointConstants`1.get_Pi -M:System.Numerics.IFloatingPointConstants`1.get_Tau -M:System.Numerics.IFloatingPointIeee754`1.Atan2(`0,`0) -M:System.Numerics.IFloatingPointIeee754`1.Atan2Pi(`0,`0) -M:System.Numerics.IFloatingPointIeee754`1.BitDecrement(`0) -M:System.Numerics.IFloatingPointIeee754`1.BitIncrement(`0) -M:System.Numerics.IFloatingPointIeee754`1.FusedMultiplyAdd(`0,`0,`0) -M:System.Numerics.IFloatingPointIeee754`1.get_Epsilon -M:System.Numerics.IFloatingPointIeee754`1.get_NaN -M:System.Numerics.IFloatingPointIeee754`1.get_NegativeInfinity -M:System.Numerics.IFloatingPointIeee754`1.get_NegativeZero -M:System.Numerics.IFloatingPointIeee754`1.get_PositiveInfinity -M:System.Numerics.IFloatingPointIeee754`1.Ieee754Remainder(`0,`0) -M:System.Numerics.IFloatingPointIeee754`1.ILogB(`0) -M:System.Numerics.IFloatingPointIeee754`1.Lerp(`0,`0,`0) -M:System.Numerics.IFloatingPointIeee754`1.ReciprocalEstimate(`0) -M:System.Numerics.IFloatingPointIeee754`1.ReciprocalSqrtEstimate(`0) -M:System.Numerics.IFloatingPointIeee754`1.ScaleB(`0,System.Int32) -M:System.Numerics.IHyperbolicFunctions`1.Acosh(`0) -M:System.Numerics.IHyperbolicFunctions`1.Asinh(`0) -M:System.Numerics.IHyperbolicFunctions`1.Atanh(`0) -M:System.Numerics.IHyperbolicFunctions`1.Cosh(`0) -M:System.Numerics.IHyperbolicFunctions`1.Sinh(`0) -M:System.Numerics.IHyperbolicFunctions`1.Tanh(`0) -M:System.Numerics.IIncrementOperators`1.op_CheckedIncrement(`0) -M:System.Numerics.IIncrementOperators`1.op_Increment(`0) -M:System.Numerics.ILogarithmicFunctions`1.Log(`0) -M:System.Numerics.ILogarithmicFunctions`1.Log(`0,`0) -M:System.Numerics.ILogarithmicFunctions`1.Log10(`0) -M:System.Numerics.ILogarithmicFunctions`1.Log10P1(`0) -M:System.Numerics.ILogarithmicFunctions`1.Log2(`0) -M:System.Numerics.ILogarithmicFunctions`1.Log2P1(`0) -M:System.Numerics.ILogarithmicFunctions`1.LogP1(`0) -M:System.Numerics.IMinMaxValue`1.get_MaxValue -M:System.Numerics.IMinMaxValue`1.get_MinValue -M:System.Numerics.IModulusOperators`3.op_Modulus(`0,`1) -M:System.Numerics.IMultiplicativeIdentity`2.get_MultiplicativeIdentity -M:System.Numerics.IMultiplyOperators`3.op_CheckedMultiply(`0,`1) -M:System.Numerics.IMultiplyOperators`3.op_Multiply(`0,`1) -M:System.Numerics.INumber`1.Clamp(`0,`0,`0) -M:System.Numerics.INumber`1.CopySign(`0,`0) -M:System.Numerics.INumber`1.Max(`0,`0) -M:System.Numerics.INumber`1.MaxNumber(`0,`0) -M:System.Numerics.INumber`1.Min(`0,`0) -M:System.Numerics.INumber`1.MinNumber(`0,`0) -M:System.Numerics.INumber`1.Sign(`0) -M:System.Numerics.INumberBase`1.Abs(`0) -M:System.Numerics.INumberBase`1.CreateChecked``1(``0) -M:System.Numerics.INumberBase`1.CreateSaturating``1(``0) -M:System.Numerics.INumberBase`1.CreateTruncating``1(``0) -M:System.Numerics.INumberBase`1.get_One -M:System.Numerics.INumberBase`1.get_Radix -M:System.Numerics.INumberBase`1.get_Zero -M:System.Numerics.INumberBase`1.IsCanonical(`0) -M:System.Numerics.INumberBase`1.IsComplexNumber(`0) -M:System.Numerics.INumberBase`1.IsEvenInteger(`0) -M:System.Numerics.INumberBase`1.IsFinite(`0) -M:System.Numerics.INumberBase`1.IsImaginaryNumber(`0) -M:System.Numerics.INumberBase`1.IsInfinity(`0) -M:System.Numerics.INumberBase`1.IsInteger(`0) -M:System.Numerics.INumberBase`1.IsNaN(`0) -M:System.Numerics.INumberBase`1.IsNegative(`0) -M:System.Numerics.INumberBase`1.IsNegativeInfinity(`0) -M:System.Numerics.INumberBase`1.IsNormal(`0) -M:System.Numerics.INumberBase`1.IsOddInteger(`0) -M:System.Numerics.INumberBase`1.IsPositive(`0) -M:System.Numerics.INumberBase`1.IsPositiveInfinity(`0) -M:System.Numerics.INumberBase`1.IsRealNumber(`0) -M:System.Numerics.INumberBase`1.IsSubnormal(`0) -M:System.Numerics.INumberBase`1.IsZero(`0) -M:System.Numerics.INumberBase`1.MaxMagnitude(`0,`0) -M:System.Numerics.INumberBase`1.MaxMagnitudeNumber(`0,`0) -M:System.Numerics.INumberBase`1.MinMagnitude(`0,`0) -M:System.Numerics.INumberBase`1.MinMagnitudeNumber(`0,`0) -M:System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Numerics.INumberBase`1.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Numerics.INumberBase`1.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Numerics.INumberBase`1.TryConvertFromChecked``1(``0,`0@) -M:System.Numerics.INumberBase`1.TryConvertFromSaturating``1(``0,`0@) -M:System.Numerics.INumberBase`1.TryConvertFromTruncating``1(``0,`0@) -M:System.Numerics.INumberBase`1.TryConvertToChecked``1(`0,``0@) -M:System.Numerics.INumberBase`1.TryConvertToSaturating``1(`0,``0@) -M:System.Numerics.INumberBase`1.TryConvertToTruncating``1(`0,``0@) -M:System.Numerics.INumberBase`1.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,`0@) -M:System.Numerics.INumberBase`1.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,`0@) -M:System.Numerics.INumberBase`1.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,`0@) -M:System.Numerics.IPowerFunctions`1.Pow(`0,`0) -M:System.Numerics.IRootFunctions`1.Cbrt(`0) -M:System.Numerics.IRootFunctions`1.Hypot(`0,`0) -M:System.Numerics.IRootFunctions`1.RootN(`0,System.Int32) -M:System.Numerics.IRootFunctions`1.Sqrt(`0) -M:System.Numerics.IShiftOperators`3.op_LeftShift(`0,`1) -M:System.Numerics.IShiftOperators`3.op_RightShift(`0,`1) -M:System.Numerics.IShiftOperators`3.op_UnsignedRightShift(`0,`1) -M:System.Numerics.ISignedNumber`1.get_NegativeOne -M:System.Numerics.ISubtractionOperators`3.op_CheckedSubtraction(`0,`1) -M:System.Numerics.ISubtractionOperators`3.op_Subtraction(`0,`1) -M:System.Numerics.ITrigonometricFunctions`1.Acos(`0) -M:System.Numerics.ITrigonometricFunctions`1.AcosPi(`0) -M:System.Numerics.ITrigonometricFunctions`1.Asin(`0) -M:System.Numerics.ITrigonometricFunctions`1.AsinPi(`0) -M:System.Numerics.ITrigonometricFunctions`1.Atan(`0) -M:System.Numerics.ITrigonometricFunctions`1.AtanPi(`0) -M:System.Numerics.ITrigonometricFunctions`1.Cos(`0) -M:System.Numerics.ITrigonometricFunctions`1.CosPi(`0) -M:System.Numerics.ITrigonometricFunctions`1.DegreesToRadians(`0) -M:System.Numerics.ITrigonometricFunctions`1.RadiansToDegrees(`0) -M:System.Numerics.ITrigonometricFunctions`1.Sin(`0) -M:System.Numerics.ITrigonometricFunctions`1.SinCos(`0) -M:System.Numerics.ITrigonometricFunctions`1.SinCosPi(`0) -M:System.Numerics.ITrigonometricFunctions`1.SinPi(`0) -M:System.Numerics.ITrigonometricFunctions`1.Tan(`0) -M:System.Numerics.ITrigonometricFunctions`1.TanPi(`0) -M:System.Numerics.IUnaryNegationOperators`2.op_CheckedUnaryNegation(`0) -M:System.Numerics.IUnaryNegationOperators`2.op_UnaryNegation(`0) -M:System.Numerics.IUnaryPlusOperators`2.op_UnaryPlus(`0) -M:System.Numerics.TotalOrderIeee754Comparer`1.Compare(`0,`0) -M:System.Numerics.TotalOrderIeee754Comparer`1.Equals(`0,`0) -M:System.Numerics.TotalOrderIeee754Comparer`1.Equals(System.Numerics.TotalOrderIeee754Comparer{`0}) -M:System.Numerics.TotalOrderIeee754Comparer`1.Equals(System.Object) -M:System.Numerics.TotalOrderIeee754Comparer`1.GetHashCode -M:System.Numerics.TotalOrderIeee754Comparer`1.GetHashCode(`0) -M:System.Object.#ctor -M:System.Object.Equals(System.Object) -M:System.Object.Equals(System.Object,System.Object) -M:System.Object.Finalize -M:System.Object.GetHashCode -M:System.Object.GetType -M:System.Object.MemberwiseClone -M:System.Object.ReferenceEquals(System.Object,System.Object) -M:System.Object.ToString -M:System.ObjectDisposedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ObjectDisposedException.#ctor(System.String) -M:System.ObjectDisposedException.#ctor(System.String,System.Exception) -M:System.ObjectDisposedException.#ctor(System.String,System.String) -M:System.ObjectDisposedException.get_Message -M:System.ObjectDisposedException.get_ObjectName -M:System.ObjectDisposedException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.ObjectDisposedException.ThrowIf(System.Boolean,System.Object) -M:System.ObjectDisposedException.ThrowIf(System.Boolean,System.Type) -M:System.ObsoleteAttribute.#ctor -M:System.ObsoleteAttribute.#ctor(System.String) -M:System.ObsoleteAttribute.#ctor(System.String,System.Boolean) -M:System.ObsoleteAttribute.get_DiagnosticId -M:System.ObsoleteAttribute.get_IsError -M:System.ObsoleteAttribute.get_Message -M:System.ObsoleteAttribute.get_UrlFormat -M:System.ObsoleteAttribute.set_DiagnosticId(System.String) -M:System.ObsoleteAttribute.set_UrlFormat(System.String) -M:System.OperatingSystem.#ctor(System.PlatformID,System.Version) -M:System.OperatingSystem.Clone -M:System.OperatingSystem.get_Platform -M:System.OperatingSystem.get_ServicePack -M:System.OperatingSystem.get_Version -M:System.OperatingSystem.get_VersionString -M:System.OperatingSystem.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.OperatingSystem.IsAndroid -M:System.OperatingSystem.IsAndroidVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsBrowser -M:System.OperatingSystem.IsFreeBSD -M:System.OperatingSystem.IsFreeBSDVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsIOS -M:System.OperatingSystem.IsIOSVersionAtLeast(System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsLinux -M:System.OperatingSystem.IsMacCatalyst -M:System.OperatingSystem.IsMacCatalystVersionAtLeast(System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsMacOS -M:System.OperatingSystem.IsMacOSVersionAtLeast(System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsOSPlatform(System.String) -M:System.OperatingSystem.IsOSPlatformVersionAtLeast(System.String,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsTvOS -M:System.OperatingSystem.IsTvOSVersionAtLeast(System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsWasi -M:System.OperatingSystem.IsWatchOS -M:System.OperatingSystem.IsWatchOSVersionAtLeast(System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.IsWindows -M:System.OperatingSystem.IsWindowsVersionAtLeast(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.OperatingSystem.ToString -M:System.OperationCanceledException.#ctor -M:System.OperationCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.OperationCanceledException.#ctor(System.String) -M:System.OperationCanceledException.#ctor(System.String,System.Exception) -M:System.OperationCanceledException.#ctor(System.String,System.Exception,System.Threading.CancellationToken) -M:System.OperationCanceledException.#ctor(System.String,System.Threading.CancellationToken) -M:System.OperationCanceledException.#ctor(System.Threading.CancellationToken) -M:System.OperationCanceledException.get_CancellationToken -M:System.OutOfMemoryException.#ctor -M:System.OutOfMemoryException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.OutOfMemoryException.#ctor(System.String) -M:System.OutOfMemoryException.#ctor(System.String,System.Exception) -M:System.OverflowException.#ctor -M:System.OverflowException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.OverflowException.#ctor(System.String) -M:System.OverflowException.#ctor(System.String,System.Exception) -M:System.ParamArrayAttribute.#ctor -M:System.PlatformNotSupportedException.#ctor -M:System.PlatformNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.PlatformNotSupportedException.#ctor(System.String) -M:System.PlatformNotSupportedException.#ctor(System.String,System.Exception) -M:System.Predicate`1.#ctor(System.Object,System.IntPtr) -M:System.Predicate`1.BeginInvoke(`0,System.AsyncCallback,System.Object) -M:System.Predicate`1.EndInvoke(System.IAsyncResult) -M:System.Predicate`1.Invoke(`0) -M:System.Progress`1.#ctor -M:System.Progress`1.#ctor(System.Action{`0}) -M:System.Progress`1.add_ProgressChanged(System.EventHandler{`0}) -M:System.Progress`1.OnReport(`0) -M:System.Progress`1.remove_ProgressChanged(System.EventHandler{`0}) -M:System.Random.#ctor -M:System.Random.#ctor(System.Int32) -M:System.Random.get_Shared -M:System.Random.GetItems``1(``0[],System.Int32) -M:System.Random.GetItems``1(System.ReadOnlySpan{``0},System.Int32) -M:System.Random.GetItems``1(System.ReadOnlySpan{``0},System.Span{``0}) -M:System.Random.Next -M:System.Random.Next(System.Int32) -M:System.Random.Next(System.Int32,System.Int32) -M:System.Random.NextBytes(System.Byte[]) -M:System.Random.NextBytes(System.Span{System.Byte}) -M:System.Random.NextDouble -M:System.Random.NextInt64 -M:System.Random.NextInt64(System.Int64) -M:System.Random.NextInt64(System.Int64,System.Int64) -M:System.Random.NextSingle -M:System.Random.Sample -M:System.Random.Shuffle``1(``0[]) -M:System.Random.Shuffle``1(System.Span{``0}) -M:System.Range.#ctor(System.Index,System.Index) -M:System.Range.EndAt(System.Index) -M:System.Range.Equals(System.Object) -M:System.Range.Equals(System.Range) -M:System.Range.get_All -M:System.Range.get_End -M:System.Range.get_Start -M:System.Range.GetHashCode -M:System.Range.GetOffsetAndLength(System.Int32) -M:System.Range.StartAt(System.Index) -M:System.Range.ToString -M:System.RankException.#ctor -M:System.RankException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.RankException.#ctor(System.String) -M:System.RankException.#ctor(System.String,System.Exception) -M:System.ReadOnlyMemory`1.#ctor(`0[]) -M:System.ReadOnlyMemory`1.#ctor(`0[],System.Int32,System.Int32) -M:System.ReadOnlyMemory`1.CopyTo(System.Memory{`0}) -M:System.ReadOnlyMemory`1.Equals(System.Object) -M:System.ReadOnlyMemory`1.Equals(System.ReadOnlyMemory{`0}) -M:System.ReadOnlyMemory`1.get_Empty -M:System.ReadOnlyMemory`1.get_IsEmpty -M:System.ReadOnlyMemory`1.get_Length -M:System.ReadOnlyMemory`1.get_Span -M:System.ReadOnlyMemory`1.GetHashCode -M:System.ReadOnlyMemory`1.op_Implicit(`0[])~System.ReadOnlyMemory{`0} -M:System.ReadOnlyMemory`1.op_Implicit(System.ArraySegment{`0})~System.ReadOnlyMemory{`0} -M:System.ReadOnlyMemory`1.Pin -M:System.ReadOnlyMemory`1.Slice(System.Int32) -M:System.ReadOnlyMemory`1.Slice(System.Int32,System.Int32) -M:System.ReadOnlyMemory`1.ToArray -M:System.ReadOnlyMemory`1.ToString -M:System.ReadOnlyMemory`1.TryCopyTo(System.Memory{`0}) -M:System.ReadOnlySpan`1.#ctor(`0@) -M:System.ReadOnlySpan`1.#ctor(`0[]) -M:System.ReadOnlySpan`1.#ctor(`0[],System.Int32,System.Int32) -M:System.ReadOnlySpan`1.#ctor(System.Void*,System.Int32) -M:System.ReadOnlySpan`1.CopyTo(System.Span{`0}) -M:System.ReadOnlySpan`1.Enumerator.get_Current -M:System.ReadOnlySpan`1.Enumerator.MoveNext -M:System.ReadOnlySpan`1.Equals(System.Object) -M:System.ReadOnlySpan`1.get_Empty -M:System.ReadOnlySpan`1.get_IsEmpty -M:System.ReadOnlySpan`1.get_Item(System.Int32) -M:System.ReadOnlySpan`1.get_Length -M:System.ReadOnlySpan`1.GetEnumerator -M:System.ReadOnlySpan`1.GetHashCode -M:System.ReadOnlySpan`1.GetPinnableReference -M:System.ReadOnlySpan`1.op_Equality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0}) -M:System.ReadOnlySpan`1.op_Implicit(`0[])~System.ReadOnlySpan{`0} -M:System.ReadOnlySpan`1.op_Implicit(System.ArraySegment{`0})~System.ReadOnlySpan{`0} -M:System.ReadOnlySpan`1.op_Inequality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0}) -M:System.ReadOnlySpan`1.Slice(System.Int32) -M:System.ReadOnlySpan`1.Slice(System.Int32,System.Int32) -M:System.ReadOnlySpan`1.ToArray -M:System.ReadOnlySpan`1.ToString -M:System.ReadOnlySpan`1.TryCopyTo(System.Span{`0}) -M:System.ResolveEventArgs.#ctor(System.String) -M:System.ResolveEventArgs.#ctor(System.String,System.Reflection.Assembly) -M:System.ResolveEventArgs.get_Name -M:System.ResolveEventArgs.get_RequestingAssembly -M:System.ResolveEventHandler.#ctor(System.Object,System.IntPtr) -M:System.ResolveEventHandler.BeginInvoke(System.Object,System.ResolveEventArgs,System.AsyncCallback,System.Object) -M:System.ResolveEventHandler.EndInvoke(System.IAsyncResult) -M:System.ResolveEventHandler.Invoke(System.Object,System.ResolveEventArgs) -M:System.Runtime.CompilerServices.AccessedThroughPropertyAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.AccessedThroughPropertyAttribute.get_PropertyName -M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete -M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Create -M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.MoveNext``1(``0@) -M:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute.#ctor(System.Type) -M:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.#ctor(System.Type) -M:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.get_BuilderType -M:System.Runtime.CompilerServices.AsyncStateMachineAttribute.#ctor(System.Type) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.get_Task -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start``1(``0@) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Create -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.get_Task -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(System.Exception) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetResult(`0) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.Start``1(``0@) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.Create -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.get_Task -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetException(System.Exception) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetResult -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder.Start``1(``0@) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.get_Task -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetException(System.Exception) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetResult(`0) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start``1(``0@) -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetException(System.Exception) -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetResult -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Start``1(``0@) -M:System.Runtime.CompilerServices.CallConvCdecl.#ctor -M:System.Runtime.CompilerServices.CallConvFastcall.#ctor -M:System.Runtime.CompilerServices.CallConvMemberFunction.#ctor -M:System.Runtime.CompilerServices.CallConvStdcall.#ctor -M:System.Runtime.CompilerServices.CallConvSuppressGCTransition.#ctor -M:System.Runtime.CompilerServices.CallConvThiscall.#ctor -M:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.get_ParameterName -M:System.Runtime.CompilerServices.CallerFilePathAttribute.#ctor -M:System.Runtime.CompilerServices.CallerLineNumberAttribute.#ctor -M:System.Runtime.CompilerServices.CallerMemberNameAttribute.#ctor -M:System.Runtime.CompilerServices.CollectionBuilderAttribute.#ctor(System.Type,System.String) -M:System.Runtime.CompilerServices.CollectionBuilderAttribute.get_BuilderType -M:System.Runtime.CompilerServices.CollectionBuilderAttribute.get_MethodName -M:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.#ctor(System.Int32) -M:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.#ctor(System.Runtime.CompilerServices.CompilationRelaxations) -M:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.get_CompilationRelaxations -M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.get_FeatureName -M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.get_IsOptional -M:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute.set_IsOptional(System.Boolean) -M:System.Runtime.CompilerServices.CompilerGeneratedAttribute.#ctor -M:System.Runtime.CompilerServices.CompilerGlobalScopeAttribute.#ctor -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.#ctor -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.Add(`0,`1) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.AddOrUpdate(`0,`1) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.Clear -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.#ctor(System.Object,System.IntPtr) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.BeginInvoke(`0,System.AsyncCallback,System.Object) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.EndInvoke(System.IAsyncResult) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback.Invoke(`0) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.GetOrCreateValue(`0) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.GetValue(`0,System.Runtime.CompilerServices.ConditionalWeakTable{`0,`1}.CreateValueCallback) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.Remove(`0) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.TryAdd(`0,`1) -M:System.Runtime.CompilerServices.ConditionalWeakTable`2.TryGetValue(`0,`1@) -M:System.Runtime.CompilerServices.ConfiguredAsyncDisposable.DisposeAsync -M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.ConfigureAwait(System.Boolean) -M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.DisposeAsync -M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.get_Current -M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.MoveNextAsync -M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.GetAsyncEnumerator -M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.WithCancellation(System.Threading.CancellationToken) -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.GetResult -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.GetAwaiter -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.GetResult -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.GetAwaiter -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.GetResult -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.GetAwaiter -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.GetResult -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.GetAwaiter -M:System.Runtime.CompilerServices.CustomConstantAttribute.#ctor -M:System.Runtime.CompilerServices.CustomConstantAttribute.get_Value -M:System.Runtime.CompilerServices.DateTimeConstantAttribute.#ctor(System.Int64) -M:System.Runtime.CompilerServices.DateTimeConstantAttribute.get_Value -M:System.Runtime.CompilerServices.DecimalConstantAttribute.#ctor(System.Byte,System.Byte,System.Int32,System.Int32,System.Int32) -M:System.Runtime.CompilerServices.DecimalConstantAttribute.#ctor(System.Byte,System.Byte,System.UInt32,System.UInt32,System.UInt32) -M:System.Runtime.CompilerServices.DecimalConstantAttribute.get_Value -M:System.Runtime.CompilerServices.DefaultDependencyAttribute.#ctor(System.Runtime.CompilerServices.LoadHint) -M:System.Runtime.CompilerServices.DefaultDependencyAttribute.get_LoadHint -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.IFormatProvider) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.IFormatProvider,System.Span{System.Char}) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted``1(``0,System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(System.String) -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToString -M:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.ToStringAndClear -M:System.Runtime.CompilerServices.DependencyAttribute.#ctor(System.String,System.Runtime.CompilerServices.LoadHint) -M:System.Runtime.CompilerServices.DependencyAttribute.get_DependentAssembly -M:System.Runtime.CompilerServices.DependencyAttribute.get_LoadHint -M:System.Runtime.CompilerServices.DisablePrivateReflectionAttribute.#ctor -M:System.Runtime.CompilerServices.DisableRuntimeMarshallingAttribute.#ctor -M:System.Runtime.CompilerServices.DiscardableAttribute.#ctor -M:System.Runtime.CompilerServices.EnumeratorCancellationAttribute.#ctor -M:System.Runtime.CompilerServices.ExtensionAttribute.#ctor -M:System.Runtime.CompilerServices.FixedAddressValueTypeAttribute.#ctor -M:System.Runtime.CompilerServices.FixedBufferAttribute.#ctor(System.Type,System.Int32) -M:System.Runtime.CompilerServices.FixedBufferAttribute.get_ElementType -M:System.Runtime.CompilerServices.FixedBufferAttribute.get_Length -M:System.Runtime.CompilerServices.FormattableStringFactory.Create(System.String,System.Object[]) -M:System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext -M:System.Runtime.CompilerServices.IAsyncStateMachine.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.ICriticalNotifyCompletion.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.IndexerNameAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.InlineArrayAttribute.#ctor(System.Int32) -M:System.Runtime.CompilerServices.InlineArrayAttribute.get_Length -M:System.Runtime.CompilerServices.INotifyCompletion.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.get_AllInternalsVisible -M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.get_AssemblyName -M:System.Runtime.CompilerServices.InternalsVisibleToAttribute.set_AllInternalsVisible(System.Boolean) -M:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.#ctor(System.String[]) -M:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute.get_Arguments -M:System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute.#ctor -M:System.Runtime.CompilerServices.IsByRefLikeAttribute.#ctor -M:System.Runtime.CompilerServices.IsReadOnlyAttribute.#ctor -M:System.Runtime.CompilerServices.IStrongBox.get_Value -M:System.Runtime.CompilerServices.IStrongBox.set_Value(System.Object) -M:System.Runtime.CompilerServices.IsUnmanagedAttribute.#ctor -M:System.Runtime.CompilerServices.IteratorStateMachineAttribute.#ctor(System.Type) -M:System.Runtime.CompilerServices.ITuple.get_Item(System.Int32) -M:System.Runtime.CompilerServices.ITuple.get_Length -M:System.Runtime.CompilerServices.MethodImplAttribute.#ctor -M:System.Runtime.CompilerServices.MethodImplAttribute.#ctor(System.Int16) -M:System.Runtime.CompilerServices.MethodImplAttribute.#ctor(System.Runtime.CompilerServices.MethodImplOptions) -M:System.Runtime.CompilerServices.MethodImplAttribute.get_Value -M:System.Runtime.CompilerServices.ModuleInitializerAttribute.#ctor -M:System.Runtime.CompilerServices.NullableAttribute.#ctor(System.Byte) -M:System.Runtime.CompilerServices.NullableAttribute.#ctor(System.Byte[]) -M:System.Runtime.CompilerServices.NullableContextAttribute.#ctor(System.Byte) -M:System.Runtime.CompilerServices.NullablePublicOnlyAttribute.#ctor(System.Boolean) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.Create -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.get_Task -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetException(System.Exception) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetResult -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder.Start``1(``0@) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.Create -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.get_Task -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetException(System.Exception) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetResult(`0) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine) -M:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.Start``1(``0@) -M:System.Runtime.CompilerServices.PreserveBaseOverridesAttribute.#ctor -M:System.Runtime.CompilerServices.ReferenceAssemblyAttribute.#ctor -M:System.Runtime.CompilerServices.ReferenceAssemblyAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.ReferenceAssemblyAttribute.get_Description -M:System.Runtime.CompilerServices.RefSafetyRulesAttribute.#ctor(System.Int32) -M:System.Runtime.CompilerServices.RefSafetyRulesAttribute.get_Version -M:System.Runtime.CompilerServices.RequiredMemberAttribute.#ctor -M:System.Runtime.CompilerServices.RequiresLocationAttribute.#ctor -M:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.#ctor -M:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.get_WrapNonExceptionThrows -M:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.set_WrapNonExceptionThrows(System.Boolean) -M:System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeCompiled -M:System.Runtime.CompilerServices.RuntimeFeature.get_IsDynamicCodeSupported -M:System.Runtime.CompilerServices.RuntimeFeature.IsSupported(System.String) -M:System.Runtime.CompilerServices.RuntimeHelpers.AllocateTypeAssociatedMemory(System.Type,System.Int32) -M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.#ctor(System.Object,System.IntPtr) -M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.BeginInvoke(System.Object,System.Boolean,System.AsyncCallback,System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.EndInvoke(System.IAsyncResult) -M:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode.Invoke(System.Object,System.Boolean) -M:System.Runtime.CompilerServices.RuntimeHelpers.CreateSpan``1(System.RuntimeFieldHandle) -M:System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack -M:System.Runtime.CompilerServices.RuntimeHelpers.Equals(System.Object,System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(System.Runtime.CompilerServices.RuntimeHelpers.TryCode,System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode,System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.get_OffsetToStringData -M:System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.GetSubArray``1(``0[],System.Range) -M:System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(System.Type) -M:System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray(System.Array,System.RuntimeFieldHandle) -M:System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences``1 -M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions -M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegionsNoOP -M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareContractedDelegate(System.Delegate) -M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareDelegate(System.Delegate) -M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMethodHandle) -M:System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(System.RuntimeMethodHandle,System.RuntimeTypeHandle[]) -M:System.Runtime.CompilerServices.RuntimeHelpers.ProbeForSufficientStack -M:System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(System.RuntimeTypeHandle) -M:System.Runtime.CompilerServices.RuntimeHelpers.RunModuleConstructor(System.ModuleHandle) -M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.#ctor(System.Object,System.IntPtr) -M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.BeginInvoke(System.Object,System.AsyncCallback,System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.EndInvoke(System.IAsyncResult) -M:System.Runtime.CompilerServices.RuntimeHelpers.TryCode.Invoke(System.Object) -M:System.Runtime.CompilerServices.RuntimeHelpers.TryEnsureSufficientExecutionStack -M:System.Runtime.CompilerServices.RuntimeWrappedException.#ctor(System.Object) -M:System.Runtime.CompilerServices.RuntimeWrappedException.get_WrappedException -M:System.Runtime.CompilerServices.RuntimeWrappedException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Runtime.CompilerServices.ScopedRefAttribute.#ctor -M:System.Runtime.CompilerServices.SkipLocalsInitAttribute.#ctor -M:System.Runtime.CompilerServices.SpecialNameAttribute.#ctor -M:System.Runtime.CompilerServices.StateMachineAttribute.#ctor(System.Type) -M:System.Runtime.CompilerServices.StateMachineAttribute.get_StateMachineType -M:System.Runtime.CompilerServices.StringFreezingAttribute.#ctor -M:System.Runtime.CompilerServices.StrongBox`1.#ctor -M:System.Runtime.CompilerServices.StrongBox`1.#ctor(`0) -M:System.Runtime.CompilerServices.SuppressIldasmAttribute.#ctor -M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor -M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.Exception) -M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.Object) -M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.String) -M:System.Runtime.CompilerServices.SwitchExpressionException.#ctor(System.String,System.Exception) -M:System.Runtime.CompilerServices.SwitchExpressionException.get_Message -M:System.Runtime.CompilerServices.SwitchExpressionException.get_UnmatchedValue -M:System.Runtime.CompilerServices.SwitchExpressionException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Runtime.CompilerServices.TaskAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.TaskAwaiter.GetResult -M:System.Runtime.CompilerServices.TaskAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.TaskAwaiter.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.TaskAwaiter`1.get_IsCompleted -M:System.Runtime.CompilerServices.TaskAwaiter`1.GetResult -M:System.Runtime.CompilerServices.TaskAwaiter`1.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.TaskAwaiter`1.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.TupleElementNamesAttribute.#ctor(System.String[]) -M:System.Runtime.CompilerServices.TupleElementNamesAttribute.get_TransformNames -M:System.Runtime.CompilerServices.TypeForwardedFromAttribute.#ctor(System.String) -M:System.Runtime.CompilerServices.TypeForwardedFromAttribute.get_AssemblyFullName -M:System.Runtime.CompilerServices.TypeForwardedToAttribute.#ctor(System.Type) -M:System.Runtime.CompilerServices.TypeForwardedToAttribute.get_Destination -M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.Int32) -M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.IntPtr) -M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.UIntPtr) -M:System.Runtime.CompilerServices.Unsafe.Add``1(System.Void*,System.Int32) -M:System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.IntPtr) -M:System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.UIntPtr) -M:System.Runtime.CompilerServices.Unsafe.AreSame``1(``0@,``0@) -M:System.Runtime.CompilerServices.Unsafe.As``1(System.Object) -M:System.Runtime.CompilerServices.Unsafe.As``2(``0@) -M:System.Runtime.CompilerServices.Unsafe.AsPointer``1(``0@) -M:System.Runtime.CompilerServices.Unsafe.AsRef``1(``0@) -M:System.Runtime.CompilerServices.Unsafe.AsRef``1(System.Void*) -M:System.Runtime.CompilerServices.Unsafe.BitCast``2(``0) -M:System.Runtime.CompilerServices.Unsafe.ByteOffset``1(``0@,``0@) -M:System.Runtime.CompilerServices.Unsafe.Copy``1(``0@,System.Void*) -M:System.Runtime.CompilerServices.Unsafe.Copy``1(System.Void*,``0@) -M:System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Byte@,System.Byte@,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Void*,System.Void*,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Byte@,System.Byte@,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Void*,System.Void*,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.InitBlock(System.Byte@,System.Byte,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.InitBlock(System.Void*,System.Byte,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Byte@,System.Byte,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Void*,System.Byte,System.UInt32) -M:System.Runtime.CompilerServices.Unsafe.IsAddressGreaterThan``1(``0@,``0@) -M:System.Runtime.CompilerServices.Unsafe.IsAddressLessThan``1(``0@,``0@) -M:System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@) -M:System.Runtime.CompilerServices.Unsafe.NullRef``1 -M:System.Runtime.CompilerServices.Unsafe.Read``1(System.Void*) -M:System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Byte@) -M:System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Void*) -M:System.Runtime.CompilerServices.Unsafe.SizeOf``1 -M:System.Runtime.CompilerServices.Unsafe.SkipInit``1(``0@) -M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.Int32) -M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.IntPtr) -M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.UIntPtr) -M:System.Runtime.CompilerServices.Unsafe.Subtract``1(System.Void*,System.Int32) -M:System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.IntPtr) -M:System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.UIntPtr) -M:System.Runtime.CompilerServices.Unsafe.Unbox``1(System.Object) -M:System.Runtime.CompilerServices.Unsafe.Write``1(System.Void*,``0) -M:System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Byte@,``0) -M:System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Void*,``0) -M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.#ctor(System.Runtime.CompilerServices.UnsafeAccessorKind) -M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.get_Kind -M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.get_Name -M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.set_Name(System.String) -M:System.Runtime.CompilerServices.UnsafeValueTypeAttribute.#ctor -M:System.Runtime.CompilerServices.ValueTaskAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult -M:System.Runtime.CompilerServices.ValueTaskAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.ValueTaskAwaiter.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.get_IsCompleted -M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult -M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.UnsafeOnCompleted(System.Action) -M:System.Runtime.CompilerServices.YieldAwaitable.GetAwaiter -M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.get_IsCompleted -M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.GetResult -M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.OnCompleted(System.Action) -M:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter.UnsafeOnCompleted(System.Action) -M:System.RuntimeFieldHandle.Equals(System.Object) -M:System.RuntimeFieldHandle.Equals(System.RuntimeFieldHandle) -M:System.RuntimeFieldHandle.FromIntPtr(System.IntPtr) -M:System.RuntimeFieldHandle.get_Value -M:System.RuntimeFieldHandle.GetHashCode -M:System.RuntimeFieldHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.RuntimeFieldHandle.op_Equality(System.RuntimeFieldHandle,System.RuntimeFieldHandle) -M:System.RuntimeFieldHandle.op_Inequality(System.RuntimeFieldHandle,System.RuntimeFieldHandle) -M:System.RuntimeFieldHandle.ToIntPtr(System.RuntimeFieldHandle) -M:System.RuntimeMethodHandle.Equals(System.Object) -M:System.RuntimeMethodHandle.Equals(System.RuntimeMethodHandle) -M:System.RuntimeMethodHandle.FromIntPtr(System.IntPtr) -M:System.RuntimeMethodHandle.get_Value -M:System.RuntimeMethodHandle.GetFunctionPointer -M:System.RuntimeMethodHandle.GetHashCode -M:System.RuntimeMethodHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.RuntimeMethodHandle.op_Equality(System.RuntimeMethodHandle,System.RuntimeMethodHandle) -M:System.RuntimeMethodHandle.op_Inequality(System.RuntimeMethodHandle,System.RuntimeMethodHandle) -M:System.RuntimeMethodHandle.ToIntPtr(System.RuntimeMethodHandle) -M:System.RuntimeTypeHandle.Equals(System.Object) -M:System.RuntimeTypeHandle.Equals(System.RuntimeTypeHandle) -M:System.RuntimeTypeHandle.FromIntPtr(System.IntPtr) -M:System.RuntimeTypeHandle.get_Value -M:System.RuntimeTypeHandle.GetHashCode -M:System.RuntimeTypeHandle.GetModuleHandle -M:System.RuntimeTypeHandle.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.RuntimeTypeHandle.op_Equality(System.Object,System.RuntimeTypeHandle) -M:System.RuntimeTypeHandle.op_Equality(System.RuntimeTypeHandle,System.Object) -M:System.RuntimeTypeHandle.op_Inequality(System.Object,System.RuntimeTypeHandle) -M:System.RuntimeTypeHandle.op_Inequality(System.RuntimeTypeHandle,System.Object) -M:System.RuntimeTypeHandle.ToIntPtr(System.RuntimeTypeHandle) -M:System.SByte.Abs(System.SByte) -M:System.SByte.Clamp(System.SByte,System.SByte,System.SByte) -M:System.SByte.CompareTo(System.Object) -M:System.SByte.CompareTo(System.SByte) -M:System.SByte.CopySign(System.SByte,System.SByte) -M:System.SByte.CreateChecked``1(``0) -M:System.SByte.CreateSaturating``1(``0) -M:System.SByte.CreateTruncating``1(``0) -M:System.SByte.DivRem(System.SByte,System.SByte) -M:System.SByte.Equals(System.Object) -M:System.SByte.Equals(System.SByte) -M:System.SByte.GetHashCode -M:System.SByte.GetTypeCode -M:System.SByte.IsEvenInteger(System.SByte) -M:System.SByte.IsNegative(System.SByte) -M:System.SByte.IsOddInteger(System.SByte) -M:System.SByte.IsPositive(System.SByte) -M:System.SByte.IsPow2(System.SByte) -M:System.SByte.LeadingZeroCount(System.SByte) -M:System.SByte.Log2(System.SByte) -M:System.SByte.Max(System.SByte,System.SByte) -M:System.SByte.MaxMagnitude(System.SByte,System.SByte) -M:System.SByte.Min(System.SByte,System.SByte) -M:System.SByte.MinMagnitude(System.SByte,System.SByte) -M:System.SByte.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.SByte.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.SByte.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.SByte.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.SByte.Parse(System.String) -M:System.SByte.Parse(System.String,System.Globalization.NumberStyles) -M:System.SByte.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.SByte.Parse(System.String,System.IFormatProvider) -M:System.SByte.PopCount(System.SByte) -M:System.SByte.RotateLeft(System.SByte,System.Int32) -M:System.SByte.RotateRight(System.SByte,System.Int32) -M:System.SByte.Sign(System.SByte) -M:System.SByte.ToString -M:System.SByte.ToString(System.IFormatProvider) -M:System.SByte.ToString(System.String) -M:System.SByte.ToString(System.String,System.IFormatProvider) -M:System.SByte.TrailingZeroCount(System.SByte) -M:System.SByte.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.SByte.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) -M:System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.SByte@) -M:System.SByte.TryParse(System.ReadOnlySpan{System.Byte},System.SByte@) -M:System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) -M:System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.SByte@) -M:System.SByte.TryParse(System.ReadOnlySpan{System.Char},System.SByte@) -M:System.SByte.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@) -M:System.SByte.TryParse(System.String,System.IFormatProvider,System.SByte@) -M:System.SByte.TryParse(System.String,System.SByte@) -M:System.SerializableAttribute.#ctor -M:System.Single.Abs(System.Single) -M:System.Single.Acos(System.Single) -M:System.Single.Acosh(System.Single) -M:System.Single.AcosPi(System.Single) -M:System.Single.Asin(System.Single) -M:System.Single.Asinh(System.Single) -M:System.Single.AsinPi(System.Single) -M:System.Single.Atan(System.Single) -M:System.Single.Atan2(System.Single,System.Single) -M:System.Single.Atan2Pi(System.Single,System.Single) -M:System.Single.Atanh(System.Single) -M:System.Single.AtanPi(System.Single) -M:System.Single.BitDecrement(System.Single) -M:System.Single.BitIncrement(System.Single) -M:System.Single.Cbrt(System.Single) -M:System.Single.Ceiling(System.Single) -M:System.Single.Clamp(System.Single,System.Single,System.Single) -M:System.Single.CompareTo(System.Object) -M:System.Single.CompareTo(System.Single) -M:System.Single.CopySign(System.Single,System.Single) -M:System.Single.Cos(System.Single) -M:System.Single.Cosh(System.Single) -M:System.Single.CosPi(System.Single) -M:System.Single.CreateChecked``1(``0) -M:System.Single.CreateSaturating``1(``0) -M:System.Single.CreateTruncating``1(``0) -M:System.Single.DegreesToRadians(System.Single) -M:System.Single.Equals(System.Object) -M:System.Single.Equals(System.Single) -M:System.Single.Exp(System.Single) -M:System.Single.Exp10(System.Single) -M:System.Single.Exp10M1(System.Single) -M:System.Single.Exp2(System.Single) -M:System.Single.Exp2M1(System.Single) -M:System.Single.ExpM1(System.Single) -M:System.Single.Floor(System.Single) -M:System.Single.FusedMultiplyAdd(System.Single,System.Single,System.Single) -M:System.Single.GetHashCode -M:System.Single.GetTypeCode -M:System.Single.Hypot(System.Single,System.Single) -M:System.Single.Ieee754Remainder(System.Single,System.Single) -M:System.Single.ILogB(System.Single) -M:System.Single.IsEvenInteger(System.Single) -M:System.Single.IsFinite(System.Single) -M:System.Single.IsInfinity(System.Single) -M:System.Single.IsInteger(System.Single) -M:System.Single.IsNaN(System.Single) -M:System.Single.IsNegative(System.Single) -M:System.Single.IsNegativeInfinity(System.Single) -M:System.Single.IsNormal(System.Single) -M:System.Single.IsOddInteger(System.Single) -M:System.Single.IsPositive(System.Single) -M:System.Single.IsPositiveInfinity(System.Single) -M:System.Single.IsPow2(System.Single) -M:System.Single.IsRealNumber(System.Single) -M:System.Single.IsSubnormal(System.Single) -M:System.Single.Lerp(System.Single,System.Single,System.Single) -M:System.Single.Log(System.Single) -M:System.Single.Log(System.Single,System.Single) -M:System.Single.Log10(System.Single) -M:System.Single.Log10P1(System.Single) -M:System.Single.Log2(System.Single) -M:System.Single.Log2P1(System.Single) -M:System.Single.LogP1(System.Single) -M:System.Single.Max(System.Single,System.Single) -M:System.Single.MaxMagnitude(System.Single,System.Single) -M:System.Single.MaxMagnitudeNumber(System.Single,System.Single) -M:System.Single.MaxNumber(System.Single,System.Single) -M:System.Single.Min(System.Single,System.Single) -M:System.Single.MinMagnitude(System.Single,System.Single) -M:System.Single.MinMagnitudeNumber(System.Single,System.Single) -M:System.Single.MinNumber(System.Single,System.Single) -M:System.Single.op_Equality(System.Single,System.Single) -M:System.Single.op_GreaterThan(System.Single,System.Single) -M:System.Single.op_GreaterThanOrEqual(System.Single,System.Single) -M:System.Single.op_Inequality(System.Single,System.Single) -M:System.Single.op_LessThan(System.Single,System.Single) -M:System.Single.op_LessThanOrEqual(System.Single,System.Single) -M:System.Single.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Single.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.Single.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Single.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Single.Parse(System.String) -M:System.Single.Parse(System.String,System.Globalization.NumberStyles) -M:System.Single.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.Single.Parse(System.String,System.IFormatProvider) -M:System.Single.Pow(System.Single,System.Single) -M:System.Single.RadiansToDegrees(System.Single) -M:System.Single.ReciprocalEstimate(System.Single) -M:System.Single.ReciprocalSqrtEstimate(System.Single) -M:System.Single.RootN(System.Single,System.Int32) -M:System.Single.Round(System.Single) -M:System.Single.Round(System.Single,System.Int32) -M:System.Single.Round(System.Single,System.Int32,System.MidpointRounding) -M:System.Single.Round(System.Single,System.MidpointRounding) -M:System.Single.ScaleB(System.Single,System.Int32) -M:System.Single.Sign(System.Single) -M:System.Single.Sin(System.Single) -M:System.Single.SinCos(System.Single) -M:System.Single.SinCosPi(System.Single) -M:System.Single.Sinh(System.Single) -M:System.Single.SinPi(System.Single) -M:System.Single.Sqrt(System.Single) -M:System.Single.Tan(System.Single) -M:System.Single.Tanh(System.Single) -M:System.Single.TanPi(System.Single) -M:System.Single.ToString -M:System.Single.ToString(System.IFormatProvider) -M:System.Single.ToString(System.String) -M:System.Single.ToString(System.String,System.IFormatProvider) -M:System.Single.Truncate(System.Single) -M:System.Single.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Single.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) -M:System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.Single@) -M:System.Single.TryParse(System.ReadOnlySpan{System.Byte},System.Single@) -M:System.Single.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) -M:System.Single.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Single@) -M:System.Single.TryParse(System.ReadOnlySpan{System.Char},System.Single@) -M:System.Single.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Single@) -M:System.Single.TryParse(System.String,System.IFormatProvider,System.Single@) -M:System.Single.TryParse(System.String,System.Single@) -M:System.Span`1.#ctor(`0@) -M:System.Span`1.#ctor(`0[]) -M:System.Span`1.#ctor(`0[],System.Int32,System.Int32) -M:System.Span`1.#ctor(System.Void*,System.Int32) -M:System.Span`1.Clear -M:System.Span`1.CopyTo(System.Span{`0}) -M:System.Span`1.Enumerator.get_Current -M:System.Span`1.Enumerator.MoveNext -M:System.Span`1.Equals(System.Object) -M:System.Span`1.Fill(`0) -M:System.Span`1.get_Empty -M:System.Span`1.get_IsEmpty -M:System.Span`1.get_Item(System.Int32) -M:System.Span`1.get_Length -M:System.Span`1.GetEnumerator -M:System.Span`1.GetHashCode -M:System.Span`1.GetPinnableReference -M:System.Span`1.op_Equality(System.Span{`0},System.Span{`0}) -M:System.Span`1.op_Implicit(`0[])~System.Span{`0} -M:System.Span`1.op_Implicit(System.ArraySegment{`0})~System.Span{`0} -M:System.Span`1.op_Implicit(System.Span{`0})~System.ReadOnlySpan{`0} -M:System.Span`1.op_Inequality(System.Span{`0},System.Span{`0}) -M:System.Span`1.Slice(System.Int32) -M:System.Span`1.Slice(System.Int32,System.Int32) -M:System.Span`1.ToArray -M:System.Span`1.ToString -M:System.Span`1.TryCopyTo(System.Span{`0}) -M:System.StackOverflowException.#ctor -M:System.StackOverflowException.#ctor(System.String) -M:System.StackOverflowException.#ctor(System.String,System.Exception) -M:System.String.#ctor(System.Char*) -M:System.String.#ctor(System.Char*,System.Int32,System.Int32) -M:System.String.#ctor(System.Char,System.Int32) -M:System.String.#ctor(System.Char[]) -M:System.String.#ctor(System.Char[],System.Int32,System.Int32) -M:System.String.#ctor(System.ReadOnlySpan{System.Char}) -M:System.String.#ctor(System.SByte*) -M:System.String.#ctor(System.SByte*,System.Int32,System.Int32) -M:System.String.#ctor(System.SByte*,System.Int32,System.Int32,System.Text.Encoding) -M:System.String.Clone -M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32) -M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean) -M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean,System.Globalization.CultureInfo) -M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CultureInfo,System.Globalization.CompareOptions) -M:System.String.Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.StringComparison) -M:System.String.Compare(System.String,System.String) -M:System.String.Compare(System.String,System.String,System.Boolean) -M:System.String.Compare(System.String,System.String,System.Boolean,System.Globalization.CultureInfo) -M:System.String.Compare(System.String,System.String,System.Globalization.CultureInfo,System.Globalization.CompareOptions) -M:System.String.Compare(System.String,System.String,System.StringComparison) -M:System.String.CompareOrdinal(System.String,System.Int32,System.String,System.Int32,System.Int32) -M:System.String.CompareOrdinal(System.String,System.String) -M:System.String.CompareTo(System.Object) -M:System.String.CompareTo(System.String) -M:System.String.Concat(System.Collections.Generic.IEnumerable{System.String}) -M:System.String.Concat(System.Object) -M:System.String.Concat(System.Object,System.Object) -M:System.String.Concat(System.Object,System.Object,System.Object) -M:System.String.Concat(System.Object[]) -M:System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:System.String.Concat(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:System.String.Concat(System.String,System.String) -M:System.String.Concat(System.String,System.String,System.String) -M:System.String.Concat(System.String,System.String,System.String,System.String) -M:System.String.Concat(System.String[]) -M:System.String.Concat``1(System.Collections.Generic.IEnumerable{``0}) -M:System.String.Contains(System.Char) -M:System.String.Contains(System.Char,System.StringComparison) -M:System.String.Contains(System.String) -M:System.String.Contains(System.String,System.StringComparison) -M:System.String.Copy(System.String) -M:System.String.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) -M:System.String.CopyTo(System.Span{System.Char}) -M:System.String.Create(System.IFormatProvider,System.Runtime.CompilerServices.DefaultInterpolatedStringHandler@) -M:System.String.Create(System.IFormatProvider,System.Span{System.Char},System.Runtime.CompilerServices.DefaultInterpolatedStringHandler@) -M:System.String.Create``1(System.Int32,``0,System.Buffers.SpanAction{System.Char,``0}) -M:System.String.EndsWith(System.Char) -M:System.String.EndsWith(System.String) -M:System.String.EndsWith(System.String,System.Boolean,System.Globalization.CultureInfo) -M:System.String.EndsWith(System.String,System.StringComparison) -M:System.String.EnumerateRunes -M:System.String.Equals(System.Object) -M:System.String.Equals(System.String) -M:System.String.Equals(System.String,System.String) -M:System.String.Equals(System.String,System.String,System.StringComparison) -M:System.String.Equals(System.String,System.StringComparison) -M:System.String.Format(System.IFormatProvider,System.String,System.Object) -M:System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object) -M:System.String.Format(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) -M:System.String.Format(System.IFormatProvider,System.String,System.Object[]) -M:System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) -M:System.String.Format(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) -M:System.String.Format(System.String,System.Object) -M:System.String.Format(System.String,System.Object,System.Object) -M:System.String.Format(System.String,System.Object,System.Object,System.Object) -M:System.String.Format(System.String,System.Object[]) -M:System.String.Format``1(System.IFormatProvider,System.Text.CompositeFormat,``0) -M:System.String.Format``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) -M:System.String.Format``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) -M:System.String.get_Chars(System.Int32) -M:System.String.get_Length -M:System.String.GetEnumerator -M:System.String.GetHashCode -M:System.String.GetHashCode(System.ReadOnlySpan{System.Char}) -M:System.String.GetHashCode(System.ReadOnlySpan{System.Char},System.StringComparison) -M:System.String.GetHashCode(System.StringComparison) -M:System.String.GetPinnableReference -M:System.String.GetTypeCode -M:System.String.IndexOf(System.Char) -M:System.String.IndexOf(System.Char,System.Int32) -M:System.String.IndexOf(System.Char,System.Int32,System.Int32) -M:System.String.IndexOf(System.Char,System.StringComparison) -M:System.String.IndexOf(System.String) -M:System.String.IndexOf(System.String,System.Int32) -M:System.String.IndexOf(System.String,System.Int32,System.Int32) -M:System.String.IndexOf(System.String,System.Int32,System.Int32,System.StringComparison) -M:System.String.IndexOf(System.String,System.Int32,System.StringComparison) -M:System.String.IndexOf(System.String,System.StringComparison) -M:System.String.IndexOfAny(System.Char[]) -M:System.String.IndexOfAny(System.Char[],System.Int32) -M:System.String.IndexOfAny(System.Char[],System.Int32,System.Int32) -M:System.String.Insert(System.Int32,System.String) -M:System.String.Intern(System.String) -M:System.String.IsInterned(System.String) -M:System.String.IsNormalized -M:System.String.IsNormalized(System.Text.NormalizationForm) -M:System.String.IsNullOrEmpty(System.String) -M:System.String.IsNullOrWhiteSpace(System.String) -M:System.String.Join(System.Char,System.Object[]) -M:System.String.Join(System.Char,System.String[]) -M:System.String.Join(System.Char,System.String[],System.Int32,System.Int32) -M:System.String.Join(System.String,System.Collections.Generic.IEnumerable{System.String}) -M:System.String.Join(System.String,System.Object[]) -M:System.String.Join(System.String,System.String[]) -M:System.String.Join(System.String,System.String[],System.Int32,System.Int32) -M:System.String.Join``1(System.Char,System.Collections.Generic.IEnumerable{``0}) -M:System.String.Join``1(System.String,System.Collections.Generic.IEnumerable{``0}) -M:System.String.LastIndexOf(System.Char) -M:System.String.LastIndexOf(System.Char,System.Int32) -M:System.String.LastIndexOf(System.Char,System.Int32,System.Int32) -M:System.String.LastIndexOf(System.String) -M:System.String.LastIndexOf(System.String,System.Int32) -M:System.String.LastIndexOf(System.String,System.Int32,System.Int32) -M:System.String.LastIndexOf(System.String,System.Int32,System.Int32,System.StringComparison) -M:System.String.LastIndexOf(System.String,System.Int32,System.StringComparison) -M:System.String.LastIndexOf(System.String,System.StringComparison) -M:System.String.LastIndexOfAny(System.Char[]) -M:System.String.LastIndexOfAny(System.Char[],System.Int32) -M:System.String.LastIndexOfAny(System.Char[],System.Int32,System.Int32) -M:System.String.Normalize -M:System.String.Normalize(System.Text.NormalizationForm) -M:System.String.op_Equality(System.String,System.String) -M:System.String.op_Implicit(System.String)~System.ReadOnlySpan{System.Char} -M:System.String.op_Inequality(System.String,System.String) -M:System.String.PadLeft(System.Int32) -M:System.String.PadLeft(System.Int32,System.Char) -M:System.String.PadRight(System.Int32) -M:System.String.PadRight(System.Int32,System.Char) -M:System.String.Remove(System.Int32) -M:System.String.Remove(System.Int32,System.Int32) -M:System.String.Replace(System.Char,System.Char) -M:System.String.Replace(System.String,System.String) -M:System.String.Replace(System.String,System.String,System.Boolean,System.Globalization.CultureInfo) -M:System.String.Replace(System.String,System.String,System.StringComparison) -M:System.String.ReplaceLineEndings -M:System.String.ReplaceLineEndings(System.String) -M:System.String.Split(System.Char,System.Int32,System.StringSplitOptions) -M:System.String.Split(System.Char,System.StringSplitOptions) -M:System.String.Split(System.Char[]) -M:System.String.Split(System.Char[],System.Int32) -M:System.String.Split(System.Char[],System.Int32,System.StringSplitOptions) -M:System.String.Split(System.Char[],System.StringSplitOptions) -M:System.String.Split(System.String,System.Int32,System.StringSplitOptions) -M:System.String.Split(System.String,System.StringSplitOptions) -M:System.String.Split(System.String[],System.Int32,System.StringSplitOptions) -M:System.String.Split(System.String[],System.StringSplitOptions) -M:System.String.StartsWith(System.Char) -M:System.String.StartsWith(System.String) -M:System.String.StartsWith(System.String,System.Boolean,System.Globalization.CultureInfo) -M:System.String.StartsWith(System.String,System.StringComparison) -M:System.String.Substring(System.Int32) -M:System.String.Substring(System.Int32,System.Int32) -M:System.String.ToCharArray -M:System.String.ToCharArray(System.Int32,System.Int32) -M:System.String.ToLower -M:System.String.ToLower(System.Globalization.CultureInfo) -M:System.String.ToLowerInvariant -M:System.String.ToString -M:System.String.ToString(System.IFormatProvider) -M:System.String.ToUpper -M:System.String.ToUpper(System.Globalization.CultureInfo) -M:System.String.ToUpperInvariant -M:System.String.Trim -M:System.String.Trim(System.Char) -M:System.String.Trim(System.Char[]) -M:System.String.TrimEnd -M:System.String.TrimEnd(System.Char) -M:System.String.TrimEnd(System.Char[]) -M:System.String.TrimStart -M:System.String.TrimStart(System.Char) -M:System.String.TrimStart(System.Char[]) -M:System.String.TryCopyTo(System.Span{System.Char}) -M:System.StringComparer.#ctor -M:System.StringComparer.Compare(System.Object,System.Object) -M:System.StringComparer.Compare(System.String,System.String) -M:System.StringComparer.Create(System.Globalization.CultureInfo,System.Boolean) -M:System.StringComparer.Create(System.Globalization.CultureInfo,System.Globalization.CompareOptions) -M:System.StringComparer.Equals(System.Object,System.Object) -M:System.StringComparer.Equals(System.String,System.String) -M:System.StringComparer.FromComparison(System.StringComparison) -M:System.StringComparer.get_CurrentCulture -M:System.StringComparer.get_CurrentCultureIgnoreCase -M:System.StringComparer.get_InvariantCulture -M:System.StringComparer.get_InvariantCultureIgnoreCase -M:System.StringComparer.get_Ordinal -M:System.StringComparer.get_OrdinalIgnoreCase -M:System.StringComparer.GetHashCode(System.Object) -M:System.StringComparer.GetHashCode(System.String) -M:System.StringComparer.IsWellKnownCultureAwareComparer(System.Collections.Generic.IEqualityComparer{System.String},System.Globalization.CompareInfo@,System.Globalization.CompareOptions@) -M:System.StringComparer.IsWellKnownOrdinalComparer(System.Collections.Generic.IEqualityComparer{System.String},System.Boolean@) -M:System.StringNormalizationExtensions.IsNormalized(System.String) -M:System.StringNormalizationExtensions.IsNormalized(System.String,System.Text.NormalizationForm) -M:System.StringNormalizationExtensions.Normalize(System.String) -M:System.StringNormalizationExtensions.Normalize(System.String,System.Text.NormalizationForm) -M:System.SystemException.#ctor -M:System.SystemException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.SystemException.#ctor(System.String) -M:System.SystemException.#ctor(System.String,System.Exception) -M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.Equals(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.EqualsIgnoreCase(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.FromUtf16(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.IsValid(System.Byte) -M:System.Text.Ascii.IsValid(System.Char) -M:System.Text.Ascii.IsValid(System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.IsValid(System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.ToLower(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.ToLowerInPlace(System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.ToLowerInPlace(System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.ToUpper(System.ReadOnlySpan{System.Char},System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.ToUpperInPlace(System.Span{System.Byte},System.Int32@) -M:System.Text.Ascii.ToUpperInPlace(System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.ToUtf16(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) -M:System.Text.Ascii.Trim(System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.Trim(System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.TrimEnd(System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.TrimEnd(System.ReadOnlySpan{System.Char}) -M:System.Text.Ascii.TrimStart(System.ReadOnlySpan{System.Byte}) -M:System.Text.Ascii.TrimStart(System.ReadOnlySpan{System.Char}) -M:System.Text.CompositeFormat.get_Format -M:System.Text.CompositeFormat.get_MinimumArgumentCount -M:System.Text.CompositeFormat.Parse(System.String) -M:System.Text.Decoder.#ctor -M:System.Text.Decoder.Convert(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) -M:System.Text.Decoder.Convert(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) -M:System.Text.Decoder.Convert(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Boolean,System.Int32@,System.Int32@,System.Boolean@) -M:System.Text.Decoder.get_Fallback -M:System.Text.Decoder.get_FallbackBuffer -M:System.Text.Decoder.GetCharCount(System.Byte*,System.Int32,System.Boolean) -M:System.Text.Decoder.GetCharCount(System.Byte[],System.Int32,System.Int32) -M:System.Text.Decoder.GetCharCount(System.Byte[],System.Int32,System.Int32,System.Boolean) -M:System.Text.Decoder.GetCharCount(System.ReadOnlySpan{System.Byte},System.Boolean) -M:System.Text.Decoder.GetChars(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean) -M:System.Text.Decoder.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) -M:System.Text.Decoder.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Boolean) -M:System.Text.Decoder.GetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Boolean) -M:System.Text.Decoder.Reset -M:System.Text.Decoder.set_Fallback(System.Text.DecoderFallback) -M:System.Text.DecoderExceptionFallback.#ctor -M:System.Text.DecoderExceptionFallback.CreateFallbackBuffer -M:System.Text.DecoderExceptionFallback.Equals(System.Object) -M:System.Text.DecoderExceptionFallback.get_MaxCharCount -M:System.Text.DecoderExceptionFallback.GetHashCode -M:System.Text.DecoderExceptionFallbackBuffer.#ctor -M:System.Text.DecoderExceptionFallbackBuffer.Fallback(System.Byte[],System.Int32) -M:System.Text.DecoderExceptionFallbackBuffer.get_Remaining -M:System.Text.DecoderExceptionFallbackBuffer.GetNextChar -M:System.Text.DecoderExceptionFallbackBuffer.MovePrevious -M:System.Text.DecoderFallback.#ctor -M:System.Text.DecoderFallback.CreateFallbackBuffer -M:System.Text.DecoderFallback.get_ExceptionFallback -M:System.Text.DecoderFallback.get_MaxCharCount -M:System.Text.DecoderFallback.get_ReplacementFallback -M:System.Text.DecoderFallbackBuffer.#ctor -M:System.Text.DecoderFallbackBuffer.Fallback(System.Byte[],System.Int32) -M:System.Text.DecoderFallbackBuffer.get_Remaining -M:System.Text.DecoderFallbackBuffer.GetNextChar -M:System.Text.DecoderFallbackBuffer.MovePrevious -M:System.Text.DecoderFallbackBuffer.Reset -M:System.Text.DecoderFallbackException.#ctor -M:System.Text.DecoderFallbackException.#ctor(System.String) -M:System.Text.DecoderFallbackException.#ctor(System.String,System.Byte[],System.Int32) -M:System.Text.DecoderFallbackException.#ctor(System.String,System.Exception) -M:System.Text.DecoderFallbackException.get_BytesUnknown -M:System.Text.DecoderFallbackException.get_Index -M:System.Text.DecoderReplacementFallback.#ctor -M:System.Text.DecoderReplacementFallback.#ctor(System.String) -M:System.Text.DecoderReplacementFallback.CreateFallbackBuffer -M:System.Text.DecoderReplacementFallback.Equals(System.Object) -M:System.Text.DecoderReplacementFallback.get_DefaultString -M:System.Text.DecoderReplacementFallback.get_MaxCharCount -M:System.Text.DecoderReplacementFallback.GetHashCode -M:System.Text.DecoderReplacementFallbackBuffer.#ctor(System.Text.DecoderReplacementFallback) -M:System.Text.DecoderReplacementFallbackBuffer.Fallback(System.Byte[],System.Int32) -M:System.Text.DecoderReplacementFallbackBuffer.get_Remaining -M:System.Text.DecoderReplacementFallbackBuffer.GetNextChar -M:System.Text.DecoderReplacementFallbackBuffer.MovePrevious -M:System.Text.DecoderReplacementFallbackBuffer.Reset -M:System.Text.Encoder.#ctor -M:System.Text.Encoder.Convert(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) -M:System.Text.Encoder.Convert(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@) -M:System.Text.Encoder.Convert(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Boolean,System.Int32@,System.Int32@,System.Boolean@) -M:System.Text.Encoder.get_Fallback -M:System.Text.Encoder.get_FallbackBuffer -M:System.Text.Encoder.GetByteCount(System.Char*,System.Int32,System.Boolean) -M:System.Text.Encoder.GetByteCount(System.Char[],System.Int32,System.Int32,System.Boolean) -M:System.Text.Encoder.GetByteCount(System.ReadOnlySpan{System.Char},System.Boolean) -M:System.Text.Encoder.GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean) -M:System.Text.Encoder.GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Boolean) -M:System.Text.Encoder.GetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Boolean) -M:System.Text.Encoder.Reset -M:System.Text.Encoder.set_Fallback(System.Text.EncoderFallback) -M:System.Text.EncoderExceptionFallback.#ctor -M:System.Text.EncoderExceptionFallback.CreateFallbackBuffer -M:System.Text.EncoderExceptionFallback.Equals(System.Object) -M:System.Text.EncoderExceptionFallback.get_MaxCharCount -M:System.Text.EncoderExceptionFallback.GetHashCode -M:System.Text.EncoderExceptionFallbackBuffer.#ctor -M:System.Text.EncoderExceptionFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) -M:System.Text.EncoderExceptionFallbackBuffer.Fallback(System.Char,System.Int32) -M:System.Text.EncoderExceptionFallbackBuffer.get_Remaining -M:System.Text.EncoderExceptionFallbackBuffer.GetNextChar -M:System.Text.EncoderExceptionFallbackBuffer.MovePrevious -M:System.Text.EncoderFallback.#ctor -M:System.Text.EncoderFallback.CreateFallbackBuffer -M:System.Text.EncoderFallback.get_ExceptionFallback -M:System.Text.EncoderFallback.get_MaxCharCount -M:System.Text.EncoderFallback.get_ReplacementFallback -M:System.Text.EncoderFallbackBuffer.#ctor -M:System.Text.EncoderFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) -M:System.Text.EncoderFallbackBuffer.Fallback(System.Char,System.Int32) -M:System.Text.EncoderFallbackBuffer.get_Remaining -M:System.Text.EncoderFallbackBuffer.GetNextChar -M:System.Text.EncoderFallbackBuffer.MovePrevious -M:System.Text.EncoderFallbackBuffer.Reset -M:System.Text.EncoderFallbackException.#ctor -M:System.Text.EncoderFallbackException.#ctor(System.String) -M:System.Text.EncoderFallbackException.#ctor(System.String,System.Exception) -M:System.Text.EncoderFallbackException.get_CharUnknown -M:System.Text.EncoderFallbackException.get_CharUnknownHigh -M:System.Text.EncoderFallbackException.get_CharUnknownLow -M:System.Text.EncoderFallbackException.get_Index -M:System.Text.EncoderFallbackException.IsUnknownSurrogate -M:System.Text.EncoderReplacementFallback.#ctor -M:System.Text.EncoderReplacementFallback.#ctor(System.String) -M:System.Text.EncoderReplacementFallback.CreateFallbackBuffer -M:System.Text.EncoderReplacementFallback.Equals(System.Object) -M:System.Text.EncoderReplacementFallback.get_DefaultString -M:System.Text.EncoderReplacementFallback.get_MaxCharCount -M:System.Text.EncoderReplacementFallback.GetHashCode -M:System.Text.EncoderReplacementFallbackBuffer.#ctor(System.Text.EncoderReplacementFallback) -M:System.Text.EncoderReplacementFallbackBuffer.Fallback(System.Char,System.Char,System.Int32) -M:System.Text.EncoderReplacementFallbackBuffer.Fallback(System.Char,System.Int32) -M:System.Text.EncoderReplacementFallbackBuffer.get_Remaining -M:System.Text.EncoderReplacementFallbackBuffer.GetNextChar -M:System.Text.EncoderReplacementFallbackBuffer.MovePrevious -M:System.Text.EncoderReplacementFallbackBuffer.Reset -M:System.Text.Encoding.#ctor -M:System.Text.Encoding.#ctor(System.Int32) -M:System.Text.Encoding.#ctor(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) -M:System.Text.Encoding.Clone -M:System.Text.Encoding.Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[]) -M:System.Text.Encoding.Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[],System.Int32,System.Int32) -M:System.Text.Encoding.CreateTranscodingStream(System.IO.Stream,System.Text.Encoding,System.Text.Encoding,System.Boolean) -M:System.Text.Encoding.Equals(System.Object) -M:System.Text.Encoding.get_ASCII -M:System.Text.Encoding.get_BigEndianUnicode -M:System.Text.Encoding.get_BodyName -M:System.Text.Encoding.get_CodePage -M:System.Text.Encoding.get_DecoderFallback -M:System.Text.Encoding.get_Default -M:System.Text.Encoding.get_EncoderFallback -M:System.Text.Encoding.get_EncodingName -M:System.Text.Encoding.get_HeaderName -M:System.Text.Encoding.get_IsBrowserDisplay -M:System.Text.Encoding.get_IsBrowserSave -M:System.Text.Encoding.get_IsMailNewsDisplay -M:System.Text.Encoding.get_IsMailNewsSave -M:System.Text.Encoding.get_IsReadOnly -M:System.Text.Encoding.get_IsSingleByte -M:System.Text.Encoding.get_Latin1 -M:System.Text.Encoding.get_Preamble -M:System.Text.Encoding.get_Unicode -M:System.Text.Encoding.get_UTF32 -M:System.Text.Encoding.get_UTF7 -M:System.Text.Encoding.get_UTF8 -M:System.Text.Encoding.get_WebName -M:System.Text.Encoding.get_WindowsCodePage -M:System.Text.Encoding.GetByteCount(System.Char*,System.Int32) -M:System.Text.Encoding.GetByteCount(System.Char[]) -M:System.Text.Encoding.GetByteCount(System.Char[],System.Int32,System.Int32) -M:System.Text.Encoding.GetByteCount(System.ReadOnlySpan{System.Char}) -M:System.Text.Encoding.GetByteCount(System.String) -M:System.Text.Encoding.GetByteCount(System.String,System.Int32,System.Int32) -M:System.Text.Encoding.GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32) -M:System.Text.Encoding.GetBytes(System.Char[]) -M:System.Text.Encoding.GetBytes(System.Char[],System.Int32,System.Int32) -M:System.Text.Encoding.GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32) -M:System.Text.Encoding.GetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte}) -M:System.Text.Encoding.GetBytes(System.String) -M:System.Text.Encoding.GetBytes(System.String,System.Int32,System.Int32) -M:System.Text.Encoding.GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32) -M:System.Text.Encoding.GetCharCount(System.Byte*,System.Int32) -M:System.Text.Encoding.GetCharCount(System.Byte[]) -M:System.Text.Encoding.GetCharCount(System.Byte[],System.Int32,System.Int32) -M:System.Text.Encoding.GetCharCount(System.ReadOnlySpan{System.Byte}) -M:System.Text.Encoding.GetChars(System.Byte*,System.Int32,System.Char*,System.Int32) -M:System.Text.Encoding.GetChars(System.Byte[]) -M:System.Text.Encoding.GetChars(System.Byte[],System.Int32,System.Int32) -M:System.Text.Encoding.GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32) -M:System.Text.Encoding.GetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char}) -M:System.Text.Encoding.GetDecoder -M:System.Text.Encoding.GetEncoder -M:System.Text.Encoding.GetEncoding(System.Int32) -M:System.Text.Encoding.GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) -M:System.Text.Encoding.GetEncoding(System.String) -M:System.Text.Encoding.GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback) -M:System.Text.Encoding.GetEncodings -M:System.Text.Encoding.GetHashCode -M:System.Text.Encoding.GetMaxByteCount(System.Int32) -M:System.Text.Encoding.GetMaxCharCount(System.Int32) -M:System.Text.Encoding.GetPreamble -M:System.Text.Encoding.GetString(System.Byte*,System.Int32) -M:System.Text.Encoding.GetString(System.Byte[]) -M:System.Text.Encoding.GetString(System.Byte[],System.Int32,System.Int32) -M:System.Text.Encoding.GetString(System.ReadOnlySpan{System.Byte}) -M:System.Text.Encoding.IsAlwaysNormalized -M:System.Text.Encoding.IsAlwaysNormalized(System.Text.NormalizationForm) -M:System.Text.Encoding.RegisterProvider(System.Text.EncodingProvider) -M:System.Text.Encoding.set_DecoderFallback(System.Text.DecoderFallback) -M:System.Text.Encoding.set_EncoderFallback(System.Text.EncoderFallback) -M:System.Text.Encoding.TryGetBytes(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@) -M:System.Text.Encoding.TryGetChars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@) -M:System.Text.EncodingInfo.#ctor(System.Text.EncodingProvider,System.Int32,System.String,System.String) -M:System.Text.EncodingInfo.Equals(System.Object) -M:System.Text.EncodingInfo.get_CodePage -M:System.Text.EncodingInfo.get_DisplayName -M:System.Text.EncodingInfo.get_Name -M:System.Text.EncodingInfo.GetEncoding -M:System.Text.EncodingInfo.GetHashCode -M:System.Text.EncodingProvider.#ctor -M:System.Text.EncodingProvider.GetEncoding(System.Int32) -M:System.Text.EncodingProvider.GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback) -M:System.Text.EncodingProvider.GetEncoding(System.String) -M:System.Text.EncodingProvider.GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback) -M:System.Text.EncodingProvider.GetEncodings -M:System.Text.Rune.#ctor(System.Char) -M:System.Text.Rune.#ctor(System.Char,System.Char) -M:System.Text.Rune.#ctor(System.Int32) -M:System.Text.Rune.#ctor(System.UInt32) -M:System.Text.Rune.CompareTo(System.Text.Rune) -M:System.Text.Rune.DecodeFromUtf16(System.ReadOnlySpan{System.Char},System.Text.Rune@,System.Int32@) -M:System.Text.Rune.DecodeFromUtf8(System.ReadOnlySpan{System.Byte},System.Text.Rune@,System.Int32@) -M:System.Text.Rune.DecodeLastFromUtf16(System.ReadOnlySpan{System.Char},System.Text.Rune@,System.Int32@) -M:System.Text.Rune.DecodeLastFromUtf8(System.ReadOnlySpan{System.Byte},System.Text.Rune@,System.Int32@) -M:System.Text.Rune.EncodeToUtf16(System.Span{System.Char}) -M:System.Text.Rune.EncodeToUtf8(System.Span{System.Byte}) -M:System.Text.Rune.Equals(System.Object) -M:System.Text.Rune.Equals(System.Text.Rune) -M:System.Text.Rune.get_IsAscii -M:System.Text.Rune.get_IsBmp -M:System.Text.Rune.get_Plane -M:System.Text.Rune.get_ReplacementChar -M:System.Text.Rune.get_Utf16SequenceLength -M:System.Text.Rune.get_Utf8SequenceLength -M:System.Text.Rune.get_Value -M:System.Text.Rune.GetHashCode -M:System.Text.Rune.GetNumericValue(System.Text.Rune) -M:System.Text.Rune.GetRuneAt(System.String,System.Int32) -M:System.Text.Rune.GetUnicodeCategory(System.Text.Rune) -M:System.Text.Rune.IsControl(System.Text.Rune) -M:System.Text.Rune.IsDigit(System.Text.Rune) -M:System.Text.Rune.IsLetter(System.Text.Rune) -M:System.Text.Rune.IsLetterOrDigit(System.Text.Rune) -M:System.Text.Rune.IsLower(System.Text.Rune) -M:System.Text.Rune.IsNumber(System.Text.Rune) -M:System.Text.Rune.IsPunctuation(System.Text.Rune) -M:System.Text.Rune.IsSeparator(System.Text.Rune) -M:System.Text.Rune.IsSymbol(System.Text.Rune) -M:System.Text.Rune.IsUpper(System.Text.Rune) -M:System.Text.Rune.IsValid(System.Int32) -M:System.Text.Rune.IsValid(System.UInt32) -M:System.Text.Rune.IsWhiteSpace(System.Text.Rune) -M:System.Text.Rune.op_Equality(System.Text.Rune,System.Text.Rune) -M:System.Text.Rune.op_Explicit(System.Char)~System.Text.Rune -M:System.Text.Rune.op_Explicit(System.Int32)~System.Text.Rune -M:System.Text.Rune.op_Explicit(System.UInt32)~System.Text.Rune -M:System.Text.Rune.op_GreaterThan(System.Text.Rune,System.Text.Rune) -M:System.Text.Rune.op_GreaterThanOrEqual(System.Text.Rune,System.Text.Rune) -M:System.Text.Rune.op_Inequality(System.Text.Rune,System.Text.Rune) -M:System.Text.Rune.op_LessThan(System.Text.Rune,System.Text.Rune) -M:System.Text.Rune.op_LessThanOrEqual(System.Text.Rune,System.Text.Rune) -M:System.Text.Rune.ToLower(System.Text.Rune,System.Globalization.CultureInfo) -M:System.Text.Rune.ToLowerInvariant(System.Text.Rune) -M:System.Text.Rune.ToString -M:System.Text.Rune.ToUpper(System.Text.Rune,System.Globalization.CultureInfo) -M:System.Text.Rune.ToUpperInvariant(System.Text.Rune) -M:System.Text.Rune.TryCreate(System.Char,System.Char,System.Text.Rune@) -M:System.Text.Rune.TryCreate(System.Char,System.Text.Rune@) -M:System.Text.Rune.TryCreate(System.Int32,System.Text.Rune@) -M:System.Text.Rune.TryCreate(System.UInt32,System.Text.Rune@) -M:System.Text.Rune.TryEncodeToUtf16(System.Span{System.Char},System.Int32@) -M:System.Text.Rune.TryEncodeToUtf8(System.Span{System.Byte},System.Int32@) -M:System.Text.Rune.TryGetRuneAt(System.String,System.Int32,System.Text.Rune@) -M:System.Text.StringBuilder.#ctor -M:System.Text.StringBuilder.#ctor(System.Int32) -M:System.Text.StringBuilder.#ctor(System.Int32,System.Int32) -M:System.Text.StringBuilder.#ctor(System.String) -M:System.Text.StringBuilder.#ctor(System.String,System.Int32) -M:System.Text.StringBuilder.#ctor(System.String,System.Int32,System.Int32,System.Int32) -M:System.Text.StringBuilder.Append(System.Boolean) -M:System.Text.StringBuilder.Append(System.Byte) -M:System.Text.StringBuilder.Append(System.Char) -M:System.Text.StringBuilder.Append(System.Char*,System.Int32) -M:System.Text.StringBuilder.Append(System.Char,System.Int32) -M:System.Text.StringBuilder.Append(System.Char[]) -M:System.Text.StringBuilder.Append(System.Char[],System.Int32,System.Int32) -M:System.Text.StringBuilder.Append(System.Decimal) -M:System.Text.StringBuilder.Append(System.Double) -M:System.Text.StringBuilder.Append(System.IFormatProvider,System.Text.StringBuilder.AppendInterpolatedStringHandler@) -M:System.Text.StringBuilder.Append(System.Int16) -M:System.Text.StringBuilder.Append(System.Int32) -M:System.Text.StringBuilder.Append(System.Int64) -M:System.Text.StringBuilder.Append(System.Object) -M:System.Text.StringBuilder.Append(System.ReadOnlyMemory{System.Char}) -M:System.Text.StringBuilder.Append(System.ReadOnlySpan{System.Char}) -M:System.Text.StringBuilder.Append(System.SByte) -M:System.Text.StringBuilder.Append(System.Single) -M:System.Text.StringBuilder.Append(System.String) -M:System.Text.StringBuilder.Append(System.String,System.Int32,System.Int32) -M:System.Text.StringBuilder.Append(System.Text.StringBuilder) -M:System.Text.StringBuilder.Append(System.Text.StringBuilder,System.Int32,System.Int32) -M:System.Text.StringBuilder.Append(System.Text.StringBuilder.AppendInterpolatedStringHandler@) -M:System.Text.StringBuilder.Append(System.UInt16) -M:System.Text.StringBuilder.Append(System.UInt32) -M:System.Text.StringBuilder.Append(System.UInt64) -M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object) -M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object) -M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object,System.Object) -M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.String,System.Object[]) -M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.Object[]) -M:System.Text.StringBuilder.AppendFormat(System.IFormatProvider,System.Text.CompositeFormat,System.ReadOnlySpan{System.Object}) -M:System.Text.StringBuilder.AppendFormat(System.String,System.Object) -M:System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object) -M:System.Text.StringBuilder.AppendFormat(System.String,System.Object,System.Object,System.Object) -M:System.Text.StringBuilder.AppendFormat(System.String,System.Object[]) -M:System.Text.StringBuilder.AppendFormat``1(System.IFormatProvider,System.Text.CompositeFormat,``0) -M:System.Text.StringBuilder.AppendFormat``2(System.IFormatProvider,System.Text.CompositeFormat,``0,``1) -M:System.Text.StringBuilder.AppendFormat``3(System.IFormatProvider,System.Text.CompositeFormat,``0,``1,``2) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Text.StringBuilder) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Text.StringBuilder,System.IFormatProvider) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.String) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendFormatted``1(``0,System.String) -M:System.Text.StringBuilder.AppendInterpolatedStringHandler.AppendLiteral(System.String) -M:System.Text.StringBuilder.AppendJoin(System.Char,System.Object[]) -M:System.Text.StringBuilder.AppendJoin(System.Char,System.String[]) -M:System.Text.StringBuilder.AppendJoin(System.String,System.Object[]) -M:System.Text.StringBuilder.AppendJoin(System.String,System.String[]) -M:System.Text.StringBuilder.AppendJoin``1(System.Char,System.Collections.Generic.IEnumerable{``0}) -M:System.Text.StringBuilder.AppendJoin``1(System.String,System.Collections.Generic.IEnumerable{``0}) -M:System.Text.StringBuilder.AppendLine -M:System.Text.StringBuilder.AppendLine(System.IFormatProvider,System.Text.StringBuilder.AppendInterpolatedStringHandler@) -M:System.Text.StringBuilder.AppendLine(System.String) -M:System.Text.StringBuilder.AppendLine(System.Text.StringBuilder.AppendInterpolatedStringHandler@) -M:System.Text.StringBuilder.ChunkEnumerator.get_Current -M:System.Text.StringBuilder.ChunkEnumerator.GetEnumerator -M:System.Text.StringBuilder.ChunkEnumerator.MoveNext -M:System.Text.StringBuilder.Clear -M:System.Text.StringBuilder.CopyTo(System.Int32,System.Char[],System.Int32,System.Int32) -M:System.Text.StringBuilder.CopyTo(System.Int32,System.Span{System.Char},System.Int32) -M:System.Text.StringBuilder.EnsureCapacity(System.Int32) -M:System.Text.StringBuilder.Equals(System.ReadOnlySpan{System.Char}) -M:System.Text.StringBuilder.Equals(System.Text.StringBuilder) -M:System.Text.StringBuilder.get_Capacity -M:System.Text.StringBuilder.get_Chars(System.Int32) -M:System.Text.StringBuilder.get_Length -M:System.Text.StringBuilder.get_MaxCapacity -M:System.Text.StringBuilder.GetChunks -M:System.Text.StringBuilder.Insert(System.Int32,System.Boolean) -M:System.Text.StringBuilder.Insert(System.Int32,System.Byte) -M:System.Text.StringBuilder.Insert(System.Int32,System.Char) -M:System.Text.StringBuilder.Insert(System.Int32,System.Char[]) -M:System.Text.StringBuilder.Insert(System.Int32,System.Char[],System.Int32,System.Int32) -M:System.Text.StringBuilder.Insert(System.Int32,System.Decimal) -M:System.Text.StringBuilder.Insert(System.Int32,System.Double) -M:System.Text.StringBuilder.Insert(System.Int32,System.Int16) -M:System.Text.StringBuilder.Insert(System.Int32,System.Int32) -M:System.Text.StringBuilder.Insert(System.Int32,System.Int64) -M:System.Text.StringBuilder.Insert(System.Int32,System.Object) -M:System.Text.StringBuilder.Insert(System.Int32,System.ReadOnlySpan{System.Char}) -M:System.Text.StringBuilder.Insert(System.Int32,System.SByte) -M:System.Text.StringBuilder.Insert(System.Int32,System.Single) -M:System.Text.StringBuilder.Insert(System.Int32,System.String) -M:System.Text.StringBuilder.Insert(System.Int32,System.String,System.Int32) -M:System.Text.StringBuilder.Insert(System.Int32,System.UInt16) -M:System.Text.StringBuilder.Insert(System.Int32,System.UInt32) -M:System.Text.StringBuilder.Insert(System.Int32,System.UInt64) -M:System.Text.StringBuilder.Remove(System.Int32,System.Int32) -M:System.Text.StringBuilder.Replace(System.Char,System.Char) -M:System.Text.StringBuilder.Replace(System.Char,System.Char,System.Int32,System.Int32) -M:System.Text.StringBuilder.Replace(System.String,System.String) -M:System.Text.StringBuilder.Replace(System.String,System.String,System.Int32,System.Int32) -M:System.Text.StringBuilder.set_Capacity(System.Int32) -M:System.Text.StringBuilder.set_Chars(System.Int32,System.Char) -M:System.Text.StringBuilder.set_Length(System.Int32) -M:System.Text.StringBuilder.ToString -M:System.Text.StringBuilder.ToString(System.Int32,System.Int32) -M:System.Text.StringRuneEnumerator.get_Current -M:System.Text.StringRuneEnumerator.GetEnumerator -M:System.Text.StringRuneEnumerator.MoveNext -M:System.Text.Unicode.Utf8.FromUtf16(System.ReadOnlySpan{System.Char},System.Span{System.Byte},System.Int32@,System.Int32@,System.Boolean,System.Boolean) -M:System.Text.Unicode.Utf8.IsValid(System.ReadOnlySpan{System.Byte}) -M:System.Text.Unicode.Utf8.ToUtf16(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Int32@,System.Int32@,System.Boolean,System.Boolean) -M:System.Text.Unicode.Utf8.TryWrite(System.Span{System.Byte},System.IFormatProvider,System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler@,System.Int32@) -M:System.Text.Unicode.Utf8.TryWrite(System.Span{System.Byte},System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler@,System.Int32@) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Span{System.Byte},System.Boolean@) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.#ctor(System.Int32,System.Int32,System.Span{System.Byte},System.IFormatProvider,System.Boolean@) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.Object,System.Int32,System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Byte}) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Byte},System.Int32,System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char}) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.ReadOnlySpan{System.Char},System.Int32,System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted(System.String,System.Int32,System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.Int32,System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendFormatted``1(``0,System.String) -M:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler.AppendLiteral(System.String) -M:System.Threading.CancellationToken.#ctor(System.Boolean) -M:System.Threading.CancellationToken.Equals(System.Object) -M:System.Threading.CancellationToken.Equals(System.Threading.CancellationToken) -M:System.Threading.CancellationToken.get_CanBeCanceled -M:System.Threading.CancellationToken.get_IsCancellationRequested -M:System.Threading.CancellationToken.get_None -M:System.Threading.CancellationToken.get_WaitHandle -M:System.Threading.CancellationToken.GetHashCode -M:System.Threading.CancellationToken.op_Equality(System.Threading.CancellationToken,System.Threading.CancellationToken) -M:System.Threading.CancellationToken.op_Inequality(System.Threading.CancellationToken,System.Threading.CancellationToken) -M:System.Threading.CancellationToken.Register(System.Action) -M:System.Threading.CancellationToken.Register(System.Action,System.Boolean) -M:System.Threading.CancellationToken.Register(System.Action{System.Object,System.Threading.CancellationToken},System.Object) -M:System.Threading.CancellationToken.Register(System.Action{System.Object},System.Object) -M:System.Threading.CancellationToken.Register(System.Action{System.Object},System.Object,System.Boolean) -M:System.Threading.CancellationToken.ThrowIfCancellationRequested -M:System.Threading.CancellationToken.UnsafeRegister(System.Action{System.Object,System.Threading.CancellationToken},System.Object) -M:System.Threading.CancellationToken.UnsafeRegister(System.Action{System.Object},System.Object) -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler) -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32) -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32) -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Complete -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_Completion -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_ConcurrentScheduler -M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.get_ExclusiveScheduler -M:System.Threading.Tasks.Sources.IValueTaskSource.GetResult(System.Int16) -M:System.Threading.Tasks.Sources.IValueTaskSource.GetStatus(System.Int16) -M:System.Threading.Tasks.Sources.IValueTaskSource.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) -M:System.Threading.Tasks.Sources.IValueTaskSource`1.GetResult(System.Int16) -M:System.Threading.Tasks.Sources.IValueTaskSource`1.GetStatus(System.Int16) -M:System.Threading.Tasks.Sources.IValueTaskSource`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.get_RunContinuationsAsynchronously -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.get_Version -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetResult(System.Int16) -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetStatus(System.Int16) -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags) -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.Reset -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.set_RunContinuationsAsynchronously(System.Boolean) -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetException(System.Exception) -M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetResult(`0) -M:System.Threading.Tasks.Task.ConfigureAwait(System.Boolean) -M:System.Threading.Tasks.Task.ConfigureAwait(System.Threading.Tasks.ConfigureAwaitOptions) -M:System.Threading.Tasks.Task.Dispose -M:System.Threading.Tasks.Task.Dispose(System.Boolean) -M:System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken) -M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken) -M:System.Threading.Tasks.Task.FromException(System.Exception) -M:System.Threading.Tasks.Task.FromException``1(System.Exception) -M:System.Threading.Tasks.Task.FromResult``1(``0) -M:System.Threading.Tasks.Task.get_AsyncState -M:System.Threading.Tasks.Task.get_CompletedTask -M:System.Threading.Tasks.Task.get_CreationOptions -M:System.Threading.Tasks.Task.get_CurrentId -M:System.Threading.Tasks.Task.get_Exception -M:System.Threading.Tasks.Task.get_Factory -M:System.Threading.Tasks.Task.get_Id -M:System.Threading.Tasks.Task.get_IsCanceled -M:System.Threading.Tasks.Task.get_IsCompleted -M:System.Threading.Tasks.Task.get_IsCompletedSuccessfully -M:System.Threading.Tasks.Task.get_IsFaulted -M:System.Threading.Tasks.Task.get_Status -M:System.Threading.Tasks.Task.GetAwaiter -M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Boolean) -M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Threading.Tasks.ConfigureAwaitOptions) -M:System.Threading.Tasks.Task`1.get_Factory -M:System.Threading.Tasks.Task`1.get_Result -M:System.Threading.Tasks.Task`1.GetAwaiter -M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait(System.IAsyncDisposable,System.Boolean) -M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Boolean) -M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ToBlockingEnumerable``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.WithCancellation``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskCanceledException.#ctor -M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String) -M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception) -M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception,System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Threading.Tasks.Task) -M:System.Threading.Tasks.TaskCanceledException.get_Task -M:System.Threading.Tasks.TaskCompletionSource.#ctor -M:System.Threading.Tasks.TaskCompletionSource.#ctor(System.Object) -M:System.Threading.Tasks.TaskCompletionSource.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions) -M:System.Threading.Tasks.TaskCompletionSource.#ctor(System.Threading.Tasks.TaskCreationOptions) -M:System.Threading.Tasks.TaskCompletionSource.get_Task -M:System.Threading.Tasks.TaskCompletionSource.SetCanceled -M:System.Threading.Tasks.TaskCompletionSource.SetCanceled(System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskCompletionSource.SetException(System.Collections.Generic.IEnumerable{System.Exception}) -M:System.Threading.Tasks.TaskCompletionSource.SetException(System.Exception) -M:System.Threading.Tasks.TaskCompletionSource.SetResult -M:System.Threading.Tasks.TaskCompletionSource.TrySetCanceled -M:System.Threading.Tasks.TaskCompletionSource.TrySetCanceled(System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) -M:System.Threading.Tasks.TaskCompletionSource.TrySetException(System.Exception) -M:System.Threading.Tasks.TaskCompletionSource.TrySetResult -M:System.Threading.Tasks.TaskCompletionSource`1.#ctor -M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object) -M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions) -M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Threading.Tasks.TaskCreationOptions) -M:System.Threading.Tasks.TaskCompletionSource`1.get_Task -M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled -M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled(System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception}) -M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception) -M:System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0) -M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled -M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken) -M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception}) -M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception) -M:System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0) -M:System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task}) -M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}}) -M:System.Threading.Tasks.TaskSchedulerException.#ctor -M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Exception) -M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String) -M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String,System.Exception) -M:System.Threading.Tasks.TaskToAsyncResult.Begin(System.Threading.Tasks.Task,System.AsyncCallback,System.Object) -M:System.Threading.Tasks.TaskToAsyncResult.End(System.IAsyncResult) -M:System.Threading.Tasks.TaskToAsyncResult.End``1(System.IAsyncResult) -M:System.Threading.Tasks.TaskToAsyncResult.Unwrap(System.IAsyncResult) -M:System.Threading.Tasks.TaskToAsyncResult.Unwrap``1(System.IAsyncResult) -M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.#ctor(System.AggregateException) -M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.get_Exception -M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.get_Observed -M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.SetObserved -M:System.Threading.Tasks.ValueTask.#ctor(System.Threading.Tasks.Sources.IValueTaskSource,System.Int16) -M:System.Threading.Tasks.ValueTask.#ctor(System.Threading.Tasks.Task) -M:System.Threading.Tasks.ValueTask.AsTask -M:System.Threading.Tasks.ValueTask.ConfigureAwait(System.Boolean) -M:System.Threading.Tasks.ValueTask.Equals(System.Object) -M:System.Threading.Tasks.ValueTask.Equals(System.Threading.Tasks.ValueTask) -M:System.Threading.Tasks.ValueTask.FromCanceled(System.Threading.CancellationToken) -M:System.Threading.Tasks.ValueTask.FromCanceled``1(System.Threading.CancellationToken) -M:System.Threading.Tasks.ValueTask.FromException(System.Exception) -M:System.Threading.Tasks.ValueTask.FromException``1(System.Exception) -M:System.Threading.Tasks.ValueTask.FromResult``1(``0) -M:System.Threading.Tasks.ValueTask.get_CompletedTask -M:System.Threading.Tasks.ValueTask.get_IsCanceled -M:System.Threading.Tasks.ValueTask.get_IsCompleted -M:System.Threading.Tasks.ValueTask.get_IsCompletedSuccessfully -M:System.Threading.Tasks.ValueTask.get_IsFaulted -M:System.Threading.Tasks.ValueTask.GetAwaiter -M:System.Threading.Tasks.ValueTask.GetHashCode -M:System.Threading.Tasks.ValueTask.op_Equality(System.Threading.Tasks.ValueTask,System.Threading.Tasks.ValueTask) -M:System.Threading.Tasks.ValueTask.op_Inequality(System.Threading.Tasks.ValueTask,System.Threading.Tasks.ValueTask) -M:System.Threading.Tasks.ValueTask.Preserve -M:System.Threading.Tasks.ValueTask`1.#ctor(`0) -M:System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Sources.IValueTaskSource{`0},System.Int16) -M:System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Task{`0}) -M:System.Threading.Tasks.ValueTask`1.AsTask -M:System.Threading.Tasks.ValueTask`1.ConfigureAwait(System.Boolean) -M:System.Threading.Tasks.ValueTask`1.Equals(System.Object) -M:System.Threading.Tasks.ValueTask`1.Equals(System.Threading.Tasks.ValueTask{`0}) -M:System.Threading.Tasks.ValueTask`1.get_IsCanceled -M:System.Threading.Tasks.ValueTask`1.get_IsCompleted -M:System.Threading.Tasks.ValueTask`1.get_IsCompletedSuccessfully -M:System.Threading.Tasks.ValueTask`1.get_IsFaulted -M:System.Threading.Tasks.ValueTask`1.get_Result -M:System.Threading.Tasks.ValueTask`1.GetAwaiter -M:System.Threading.Tasks.ValueTask`1.GetHashCode -M:System.Threading.Tasks.ValueTask`1.op_Equality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0}) -M:System.Threading.Tasks.ValueTask`1.op_Inequality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0}) -M:System.Threading.Tasks.ValueTask`1.Preserve -M:System.Threading.Tasks.ValueTask`1.ToString -M:System.TimeOnly.#ctor(System.Int32,System.Int32) -M:System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32) -M:System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.TimeOnly.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.TimeOnly.#ctor(System.Int64) -M:System.TimeOnly.Add(System.TimeSpan) -M:System.TimeOnly.Add(System.TimeSpan,System.Int32@) -M:System.TimeOnly.AddHours(System.Double) -M:System.TimeOnly.AddHours(System.Double,System.Int32@) -M:System.TimeOnly.AddMinutes(System.Double) -M:System.TimeOnly.AddMinutes(System.Double,System.Int32@) -M:System.TimeOnly.CompareTo(System.Object) -M:System.TimeOnly.CompareTo(System.TimeOnly) -M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@) -M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@) -M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@,System.Int32@) -M:System.TimeOnly.Deconstruct(System.Int32@,System.Int32@,System.Int32@,System.Int32@,System.Int32@) -M:System.TimeOnly.Equals(System.Object) -M:System.TimeOnly.Equals(System.TimeOnly) -M:System.TimeOnly.FromDateTime(System.DateTime) -M:System.TimeOnly.FromTimeSpan(System.TimeSpan) -M:System.TimeOnly.get_Hour -M:System.TimeOnly.get_MaxValue -M:System.TimeOnly.get_Microsecond -M:System.TimeOnly.get_Millisecond -M:System.TimeOnly.get_Minute -M:System.TimeOnly.get_MinValue -M:System.TimeOnly.get_Nanosecond -M:System.TimeOnly.get_Second -M:System.TimeOnly.get_Ticks -M:System.TimeOnly.GetHashCode -M:System.TimeOnly.IsBetween(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_Equality(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_GreaterThan(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_GreaterThanOrEqual(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_Inequality(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_LessThan(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_LessThanOrEqual(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.op_Subtraction(System.TimeOnly,System.TimeOnly) -M:System.TimeOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.TimeOnly.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.TimeOnly.Parse(System.String) -M:System.TimeOnly.Parse(System.String,System.IFormatProvider) -M:System.TimeOnly.Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[]) -M:System.TimeOnly.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.TimeOnly.ParseExact(System.String,System.String) -M:System.TimeOnly.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.TimeOnly.ParseExact(System.String,System.String[]) -M:System.TimeOnly.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles) -M:System.TimeOnly.ToLongTimeString -M:System.TimeOnly.ToShortTimeString -M:System.TimeOnly.ToString -M:System.TimeOnly.ToString(System.IFormatProvider) -M:System.TimeOnly.ToString(System.String) -M:System.TimeOnly.ToString(System.String,System.IFormatProvider) -M:System.TimeOnly.ToTimeSpan -M:System.TimeOnly.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.TimeOnly.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) -M:System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeOnly@) -M:System.TimeOnly.TryParse(System.ReadOnlySpan{System.Char},System.TimeOnly@) -M:System.TimeOnly.TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) -M:System.TimeOnly.TryParse(System.String,System.IFormatProvider,System.TimeOnly@) -M:System.TimeOnly.TryParse(System.String,System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.String,System.String,System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.TimeOnly@) -M:System.TimeOnly.TryParseExact(System.String,System.String[],System.TimeOnly@) -M:System.TimeoutException.#ctor -M:System.TimeoutException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TimeoutException.#ctor(System.String) -M:System.TimeoutException.#ctor(System.String,System.Exception) -M:System.TimeProvider.#ctor -M:System.TimeProvider.CreateTimer(System.Threading.TimerCallback,System.Object,System.TimeSpan,System.TimeSpan) -M:System.TimeProvider.get_LocalTimeZone -M:System.TimeProvider.get_System -M:System.TimeProvider.get_TimestampFrequency -M:System.TimeProvider.GetElapsedTime(System.Int64) -M:System.TimeProvider.GetElapsedTime(System.Int64,System.Int64) -M:System.TimeProvider.GetLocalNow -M:System.TimeProvider.GetTimestamp -M:System.TimeProvider.GetUtcNow -M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32) -M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.TimeSpan.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32) -M:System.TimeSpan.#ctor(System.Int64) -M:System.TimeSpan.Add(System.TimeSpan) -M:System.TimeSpan.Compare(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.CompareTo(System.Object) -M:System.TimeSpan.CompareTo(System.TimeSpan) -M:System.TimeSpan.Divide(System.Double) -M:System.TimeSpan.Divide(System.TimeSpan) -M:System.TimeSpan.Duration -M:System.TimeSpan.Equals(System.Object) -M:System.TimeSpan.Equals(System.TimeSpan) -M:System.TimeSpan.Equals(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.FromDays(System.Double) -M:System.TimeSpan.FromHours(System.Double) -M:System.TimeSpan.FromMicroseconds(System.Double) -M:System.TimeSpan.FromMilliseconds(System.Double) -M:System.TimeSpan.FromMinutes(System.Double) -M:System.TimeSpan.FromSeconds(System.Double) -M:System.TimeSpan.FromTicks(System.Int64) -M:System.TimeSpan.get_Days -M:System.TimeSpan.get_Hours -M:System.TimeSpan.get_Microseconds -M:System.TimeSpan.get_Milliseconds -M:System.TimeSpan.get_Minutes -M:System.TimeSpan.get_Nanoseconds -M:System.TimeSpan.get_Seconds -M:System.TimeSpan.get_Ticks -M:System.TimeSpan.get_TotalDays -M:System.TimeSpan.get_TotalHours -M:System.TimeSpan.get_TotalMicroseconds -M:System.TimeSpan.get_TotalMilliseconds -M:System.TimeSpan.get_TotalMinutes -M:System.TimeSpan.get_TotalNanoseconds -M:System.TimeSpan.get_TotalSeconds -M:System.TimeSpan.GetHashCode -M:System.TimeSpan.Multiply(System.Double) -M:System.TimeSpan.Negate -M:System.TimeSpan.op_Addition(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_Division(System.TimeSpan,System.Double) -M:System.TimeSpan.op_Division(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_Equality(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_GreaterThan(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_GreaterThanOrEqual(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_Inequality(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_LessThan(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_LessThanOrEqual(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_Multiply(System.Double,System.TimeSpan) -M:System.TimeSpan.op_Multiply(System.TimeSpan,System.Double) -M:System.TimeSpan.op_Subtraction(System.TimeSpan,System.TimeSpan) -M:System.TimeSpan.op_UnaryNegation(System.TimeSpan) -M:System.TimeSpan.op_UnaryPlus(System.TimeSpan) -M:System.TimeSpan.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.TimeSpan.Parse(System.String) -M:System.TimeSpan.Parse(System.String,System.IFormatProvider) -M:System.TimeSpan.ParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.TimeSpanStyles) -M:System.TimeSpan.ParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) -M:System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider) -M:System.TimeSpan.ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles) -M:System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider) -M:System.TimeSpan.ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles) -M:System.TimeSpan.Subtract(System.TimeSpan) -M:System.TimeSpan.ToString -M:System.TimeSpan.ToString(System.String) -M:System.TimeSpan.ToString(System.String,System.IFormatProvider) -M:System.TimeSpan.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.TimeSpan.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.TimeSpan.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeSpan@) -M:System.TimeSpan.TryParse(System.ReadOnlySpan{System.Char},System.TimeSpan@) -M:System.TimeSpan.TryParse(System.String,System.IFormatProvider,System.TimeSpan@) -M:System.TimeSpan.TryParse(System.String,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.IFormatProvider,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.ReadOnlySpan{System.Char},System.String[],System.IFormatProvider,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.String,System.String,System.IFormatProvider,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@) -M:System.TimeSpan.TryParseExact(System.String,System.String[],System.IFormatProvider,System.TimeSpan@) -M:System.TimeZone.#ctor -M:System.TimeZone.get_CurrentTimeZone -M:System.TimeZone.get_DaylightName -M:System.TimeZone.get_StandardName -M:System.TimeZone.GetDaylightChanges(System.Int32) -M:System.TimeZone.GetUtcOffset(System.DateTime) -M:System.TimeZone.IsDaylightSavingTime(System.DateTime) -M:System.TimeZone.IsDaylightSavingTime(System.DateTime,System.Globalization.DaylightTime) -M:System.TimeZone.ToLocalTime(System.DateTime) -M:System.TimeZone.ToUniversalTime(System.DateTime) -M:System.TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) -M:System.TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime,System.TimeSpan) -M:System.TimeZoneInfo.AdjustmentRule.Equals(System.Object) -M:System.TimeZoneInfo.AdjustmentRule.Equals(System.TimeZoneInfo.AdjustmentRule) -M:System.TimeZoneInfo.AdjustmentRule.get_BaseUtcOffsetDelta -M:System.TimeZoneInfo.AdjustmentRule.get_DateEnd -M:System.TimeZoneInfo.AdjustmentRule.get_DateStart -M:System.TimeZoneInfo.AdjustmentRule.get_DaylightDelta -M:System.TimeZoneInfo.AdjustmentRule.get_DaylightTransitionEnd -M:System.TimeZoneInfo.AdjustmentRule.get_DaylightTransitionStart -M:System.TimeZoneInfo.AdjustmentRule.GetHashCode -M:System.TimeZoneInfo.ClearCachedData -M:System.TimeZoneInfo.ConvertTime(System.DateTime,System.TimeZoneInfo) -M:System.TimeZoneInfo.ConvertTime(System.DateTime,System.TimeZoneInfo,System.TimeZoneInfo) -M:System.TimeZoneInfo.ConvertTime(System.DateTimeOffset,System.TimeZoneInfo) -M:System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTime,System.String) -M:System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTime,System.String,System.String) -M:System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId(System.DateTimeOffset,System.String) -M:System.TimeZoneInfo.ConvertTimeFromUtc(System.DateTime,System.TimeZoneInfo) -M:System.TimeZoneInfo.ConvertTimeToUtc(System.DateTime) -M:System.TimeZoneInfo.ConvertTimeToUtc(System.DateTime,System.TimeZoneInfo) -M:System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String) -M:System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo.AdjustmentRule[]) -M:System.TimeZoneInfo.CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo.AdjustmentRule[],System.Boolean) -M:System.TimeZoneInfo.Equals(System.Object) -M:System.TimeZoneInfo.Equals(System.TimeZoneInfo) -M:System.TimeZoneInfo.FindSystemTimeZoneById(System.String) -M:System.TimeZoneInfo.FromSerializedString(System.String) -M:System.TimeZoneInfo.get_BaseUtcOffset -M:System.TimeZoneInfo.get_DaylightName -M:System.TimeZoneInfo.get_DisplayName -M:System.TimeZoneInfo.get_HasIanaId -M:System.TimeZoneInfo.get_Id -M:System.TimeZoneInfo.get_Local -M:System.TimeZoneInfo.get_StandardName -M:System.TimeZoneInfo.get_SupportsDaylightSavingTime -M:System.TimeZoneInfo.get_Utc -M:System.TimeZoneInfo.GetAdjustmentRules -M:System.TimeZoneInfo.GetAmbiguousTimeOffsets(System.DateTime) -M:System.TimeZoneInfo.GetAmbiguousTimeOffsets(System.DateTimeOffset) -M:System.TimeZoneInfo.GetHashCode -M:System.TimeZoneInfo.GetSystemTimeZones -M:System.TimeZoneInfo.GetSystemTimeZones(System.Boolean) -M:System.TimeZoneInfo.GetUtcOffset(System.DateTime) -M:System.TimeZoneInfo.GetUtcOffset(System.DateTimeOffset) -M:System.TimeZoneInfo.HasSameRules(System.TimeZoneInfo) -M:System.TimeZoneInfo.IsAmbiguousTime(System.DateTime) -M:System.TimeZoneInfo.IsAmbiguousTime(System.DateTimeOffset) -M:System.TimeZoneInfo.IsDaylightSavingTime(System.DateTime) -M:System.TimeZoneInfo.IsDaylightSavingTime(System.DateTimeOffset) -M:System.TimeZoneInfo.IsInvalidTime(System.DateTime) -M:System.TimeZoneInfo.ToSerializedString -M:System.TimeZoneInfo.ToString -M:System.TimeZoneInfo.TransitionTime.CreateFixedDateRule(System.DateTime,System.Int32,System.Int32) -M:System.TimeZoneInfo.TransitionTime.CreateFloatingDateRule(System.DateTime,System.Int32,System.Int32,System.DayOfWeek) -M:System.TimeZoneInfo.TransitionTime.Equals(System.Object) -M:System.TimeZoneInfo.TransitionTime.Equals(System.TimeZoneInfo.TransitionTime) -M:System.TimeZoneInfo.TransitionTime.get_Day -M:System.TimeZoneInfo.TransitionTime.get_DayOfWeek -M:System.TimeZoneInfo.TransitionTime.get_IsFixedDateRule -M:System.TimeZoneInfo.TransitionTime.get_Month -M:System.TimeZoneInfo.TransitionTime.get_TimeOfDay -M:System.TimeZoneInfo.TransitionTime.get_Week -M:System.TimeZoneInfo.TransitionTime.GetHashCode -M:System.TimeZoneInfo.TransitionTime.op_Equality(System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) -M:System.TimeZoneInfo.TransitionTime.op_Inequality(System.TimeZoneInfo.TransitionTime,System.TimeZoneInfo.TransitionTime) -M:System.TimeZoneInfo.TryConvertIanaIdToWindowsId(System.String,System.String@) -M:System.TimeZoneInfo.TryConvertWindowsIdToIanaId(System.String,System.String,System.String@) -M:System.TimeZoneInfo.TryConvertWindowsIdToIanaId(System.String,System.String@) -M:System.TimeZoneInfo.TryFindSystemTimeZoneById(System.String,System.TimeZoneInfo@) -M:System.TimeZoneNotFoundException.#ctor -M:System.TimeZoneNotFoundException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TimeZoneNotFoundException.#ctor(System.String) -M:System.TimeZoneNotFoundException.#ctor(System.String,System.Exception) -M:System.Tuple.Create``1(``0) -M:System.Tuple.Create``2(``0,``1) -M:System.Tuple.Create``3(``0,``1,``2) -M:System.Tuple.Create``4(``0,``1,``2,``3) -M:System.Tuple.Create``5(``0,``1,``2,``3,``4) -M:System.Tuple.Create``6(``0,``1,``2,``3,``4,``5) -M:System.Tuple.Create``7(``0,``1,``2,``3,``4,``5,``6) -M:System.Tuple.Create``8(``0,``1,``2,``3,``4,``5,``6,``7) -M:System.Tuple`1.#ctor(`0) -M:System.Tuple`1.Equals(System.Object) -M:System.Tuple`1.get_Item1 -M:System.Tuple`1.GetHashCode -M:System.Tuple`1.ToString -M:System.Tuple`2.#ctor(`0,`1) -M:System.Tuple`2.Equals(System.Object) -M:System.Tuple`2.get_Item1 -M:System.Tuple`2.get_Item2 -M:System.Tuple`2.GetHashCode -M:System.Tuple`2.ToString -M:System.Tuple`3.#ctor(`0,`1,`2) -M:System.Tuple`3.Equals(System.Object) -M:System.Tuple`3.get_Item1 -M:System.Tuple`3.get_Item2 -M:System.Tuple`3.get_Item3 -M:System.Tuple`3.GetHashCode -M:System.Tuple`3.ToString -M:System.Tuple`4.#ctor(`0,`1,`2,`3) -M:System.Tuple`4.Equals(System.Object) -M:System.Tuple`4.get_Item1 -M:System.Tuple`4.get_Item2 -M:System.Tuple`4.get_Item3 -M:System.Tuple`4.get_Item4 -M:System.Tuple`4.GetHashCode -M:System.Tuple`4.ToString -M:System.Tuple`5.#ctor(`0,`1,`2,`3,`4) -M:System.Tuple`5.Equals(System.Object) -M:System.Tuple`5.get_Item1 -M:System.Tuple`5.get_Item2 -M:System.Tuple`5.get_Item3 -M:System.Tuple`5.get_Item4 -M:System.Tuple`5.get_Item5 -M:System.Tuple`5.GetHashCode -M:System.Tuple`5.ToString -M:System.Tuple`6.#ctor(`0,`1,`2,`3,`4,`5) -M:System.Tuple`6.Equals(System.Object) -M:System.Tuple`6.get_Item1 -M:System.Tuple`6.get_Item2 -M:System.Tuple`6.get_Item3 -M:System.Tuple`6.get_Item4 -M:System.Tuple`6.get_Item5 -M:System.Tuple`6.get_Item6 -M:System.Tuple`6.GetHashCode -M:System.Tuple`6.ToString -M:System.Tuple`7.#ctor(`0,`1,`2,`3,`4,`5,`6) -M:System.Tuple`7.Equals(System.Object) -M:System.Tuple`7.get_Item1 -M:System.Tuple`7.get_Item2 -M:System.Tuple`7.get_Item3 -M:System.Tuple`7.get_Item4 -M:System.Tuple`7.get_Item5 -M:System.Tuple`7.get_Item6 -M:System.Tuple`7.get_Item7 -M:System.Tuple`7.GetHashCode -M:System.Tuple`7.ToString -M:System.Tuple`8.#ctor(`0,`1,`2,`3,`4,`5,`6,`7) -M:System.Tuple`8.Equals(System.Object) -M:System.Tuple`8.get_Item1 -M:System.Tuple`8.get_Item2 -M:System.Tuple`8.get_Item3 -M:System.Tuple`8.get_Item4 -M:System.Tuple`8.get_Item5 -M:System.Tuple`8.get_Item6 -M:System.Tuple`8.get_Item7 -M:System.Tuple`8.get_Rest -M:System.Tuple`8.GetHashCode -M:System.Tuple`8.ToString -M:System.TupleExtensions.Deconstruct``1(System.Tuple{``0},``0@) -M:System.TupleExtensions.Deconstruct``10(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@) -M:System.TupleExtensions.Deconstruct``11(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@) -M:System.TupleExtensions.Deconstruct``12(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@) -M:System.TupleExtensions.Deconstruct``13(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@) -M:System.TupleExtensions.Deconstruct``14(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@) -M:System.TupleExtensions.Deconstruct``15(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@) -M:System.TupleExtensions.Deconstruct``16(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@) -M:System.TupleExtensions.Deconstruct``17(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@) -M:System.TupleExtensions.Deconstruct``18(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@) -M:System.TupleExtensions.Deconstruct``19(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@) -M:System.TupleExtensions.Deconstruct``2(System.Tuple{``0,``1},``0@,``1@) -M:System.TupleExtensions.Deconstruct``20(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@,``19@) -M:System.TupleExtensions.Deconstruct``21(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19,``20}}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@,``9@,``10@,``11@,``12@,``13@,``14@,``15@,``16@,``17@,``18@,``19@,``20@) -M:System.TupleExtensions.Deconstruct``3(System.Tuple{``0,``1,``2},``0@,``1@,``2@) -M:System.TupleExtensions.Deconstruct``4(System.Tuple{``0,``1,``2,``3},``0@,``1@,``2@,``3@) -M:System.TupleExtensions.Deconstruct``5(System.Tuple{``0,``1,``2,``3,``4},``0@,``1@,``2@,``3@,``4@) -M:System.TupleExtensions.Deconstruct``6(System.Tuple{``0,``1,``2,``3,``4,``5},``0@,``1@,``2@,``3@,``4@,``5@) -M:System.TupleExtensions.Deconstruct``7(System.Tuple{``0,``1,``2,``3,``4,``5,``6},``0@,``1@,``2@,``3@,``4@,``5@,``6@) -M:System.TupleExtensions.Deconstruct``8(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@) -M:System.TupleExtensions.Deconstruct``9(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8}},``0@,``1@,``2@,``3@,``4@,``5@,``6@,``7@,``8@) -M:System.TupleExtensions.ToTuple``1(System.ValueTuple{``0}) -M:System.TupleExtensions.ToTuple``10(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9}}) -M:System.TupleExtensions.ToTuple``11(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10}}) -M:System.TupleExtensions.ToTuple``12(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11}}) -M:System.TupleExtensions.ToTuple``13(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12}}) -M:System.TupleExtensions.ToTuple``14(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13}}) -M:System.TupleExtensions.ToTuple``15(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14}}}) -M:System.TupleExtensions.ToTuple``16(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15}}}) -M:System.TupleExtensions.ToTuple``17(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16}}}) -M:System.TupleExtensions.ToTuple``18(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17}}}) -M:System.TupleExtensions.ToTuple``19(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18}}}) -M:System.TupleExtensions.ToTuple``2(System.ValueTuple{``0,``1}) -M:System.TupleExtensions.ToTuple``20(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18,``19}}}) -M:System.TupleExtensions.ToTuple``21(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8,``9,``10,``11,``12,``13,System.ValueTuple{``14,``15,``16,``17,``18,``19,``20}}}) -M:System.TupleExtensions.ToTuple``3(System.ValueTuple{``0,``1,``2}) -M:System.TupleExtensions.ToTuple``4(System.ValueTuple{``0,``1,``2,``3}) -M:System.TupleExtensions.ToTuple``5(System.ValueTuple{``0,``1,``2,``3,``4}) -M:System.TupleExtensions.ToTuple``6(System.ValueTuple{``0,``1,``2,``3,``4,``5}) -M:System.TupleExtensions.ToTuple``7(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6}) -M:System.TupleExtensions.ToTuple``8(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7}}) -M:System.TupleExtensions.ToTuple``9(System.ValueTuple{``0,``1,``2,``3,``4,``5,``6,System.ValueTuple{``7,``8}}) -M:System.TupleExtensions.ToValueTuple``1(System.Tuple{``0}) -M:System.TupleExtensions.ToValueTuple``10(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9}}) -M:System.TupleExtensions.ToValueTuple``11(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10}}) -M:System.TupleExtensions.ToValueTuple``12(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11}}) -M:System.TupleExtensions.ToValueTuple``13(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12}}) -M:System.TupleExtensions.ToValueTuple``14(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13}}) -M:System.TupleExtensions.ToValueTuple``15(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14}}}) -M:System.TupleExtensions.ToValueTuple``16(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15}}}) -M:System.TupleExtensions.ToValueTuple``17(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16}}}) -M:System.TupleExtensions.ToValueTuple``18(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17}}}) -M:System.TupleExtensions.ToValueTuple``19(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18}}}) -M:System.TupleExtensions.ToValueTuple``2(System.Tuple{``0,``1}) -M:System.TupleExtensions.ToValueTuple``20(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19}}}) -M:System.TupleExtensions.ToValueTuple``21(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8,``9,``10,``11,``12,``13,System.Tuple{``14,``15,``16,``17,``18,``19,``20}}}) -M:System.TupleExtensions.ToValueTuple``3(System.Tuple{``0,``1,``2}) -M:System.TupleExtensions.ToValueTuple``4(System.Tuple{``0,``1,``2,``3}) -M:System.TupleExtensions.ToValueTuple``5(System.Tuple{``0,``1,``2,``3,``4}) -M:System.TupleExtensions.ToValueTuple``6(System.Tuple{``0,``1,``2,``3,``4,``5}) -M:System.TupleExtensions.ToValueTuple``7(System.Tuple{``0,``1,``2,``3,``4,``5,``6}) -M:System.TupleExtensions.ToValueTuple``8(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7}}) -M:System.TupleExtensions.ToValueTuple``9(System.Tuple{``0,``1,``2,``3,``4,``5,``6,System.Tuple{``7,``8}}) -M:System.TypeAccessException.#ctor -M:System.TypeAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TypeAccessException.#ctor(System.String) -M:System.TypeAccessException.#ctor(System.String,System.Exception) -M:System.TypedReference.Equals(System.Object) -M:System.TypedReference.GetHashCode -M:System.TypedReference.GetTargetType(System.TypedReference) -M:System.TypedReference.MakeTypedReference(System.Object,System.Reflection.FieldInfo[]) -M:System.TypedReference.SetTypedReference(System.TypedReference,System.Object) -M:System.TypedReference.TargetTypeToken(System.TypedReference) -M:System.TypedReference.ToObject(System.TypedReference) -M:System.TypeInitializationException.#ctor(System.String,System.Exception) -M:System.TypeInitializationException.get_TypeName -M:System.TypeInitializationException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TypeLoadException.#ctor -M:System.TypeLoadException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TypeLoadException.#ctor(System.String) -M:System.TypeLoadException.#ctor(System.String,System.Exception) -M:System.TypeLoadException.get_Message -M:System.TypeLoadException.get_TypeName -M:System.TypeLoadException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TypeUnloadedException.#ctor -M:System.TypeUnloadedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.TypeUnloadedException.#ctor(System.String) -M:System.TypeUnloadedException.#ctor(System.String,System.Exception) -M:System.UInt128.#ctor(System.UInt64,System.UInt64) -M:System.UInt128.Clamp(System.UInt128,System.UInt128,System.UInt128) -M:System.UInt128.CompareTo(System.Object) -M:System.UInt128.CompareTo(System.UInt128) -M:System.UInt128.CreateChecked``1(``0) -M:System.UInt128.CreateSaturating``1(``0) -M:System.UInt128.CreateTruncating``1(``0) -M:System.UInt128.DivRem(System.UInt128,System.UInt128) -M:System.UInt128.Equals(System.Object) -M:System.UInt128.Equals(System.UInt128) -M:System.UInt128.get_MaxValue -M:System.UInt128.get_MinValue -M:System.UInt128.get_One -M:System.UInt128.get_Zero -M:System.UInt128.GetHashCode -M:System.UInt128.IsEvenInteger(System.UInt128) -M:System.UInt128.IsOddInteger(System.UInt128) -M:System.UInt128.IsPow2(System.UInt128) -M:System.UInt128.LeadingZeroCount(System.UInt128) -M:System.UInt128.Log2(System.UInt128) -M:System.UInt128.Max(System.UInt128,System.UInt128) -M:System.UInt128.Min(System.UInt128,System.UInt128) -M:System.UInt128.op_Addition(System.UInt128,System.UInt128) -M:System.UInt128.op_BitwiseAnd(System.UInt128,System.UInt128) -M:System.UInt128.op_BitwiseOr(System.UInt128,System.UInt128) -M:System.UInt128.op_CheckedAddition(System.UInt128,System.UInt128) -M:System.UInt128.op_CheckedDecrement(System.UInt128) -M:System.UInt128.op_CheckedDivision(System.UInt128,System.UInt128) -M:System.UInt128.op_CheckedExplicit(System.Double)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.Int16)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.Int32)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.Int64)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.IntPtr)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.SByte)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.Single)~System.UInt128 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Byte -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Char -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int128 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int16 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int32 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.Int64 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.IntPtr -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.SByte -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt16 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt32 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UInt64 -M:System.UInt128.op_CheckedExplicit(System.UInt128)~System.UIntPtr -M:System.UInt128.op_CheckedIncrement(System.UInt128) -M:System.UInt128.op_CheckedMultiply(System.UInt128,System.UInt128) -M:System.UInt128.op_CheckedSubtraction(System.UInt128,System.UInt128) -M:System.UInt128.op_CheckedUnaryNegation(System.UInt128) -M:System.UInt128.op_Decrement(System.UInt128) -M:System.UInt128.op_Division(System.UInt128,System.UInt128) -M:System.UInt128.op_Equality(System.UInt128,System.UInt128) -M:System.UInt128.op_ExclusiveOr(System.UInt128,System.UInt128) -M:System.UInt128.op_Explicit(System.Decimal)~System.UInt128 -M:System.UInt128.op_Explicit(System.Double)~System.UInt128 -M:System.UInt128.op_Explicit(System.Int16)~System.UInt128 -M:System.UInt128.op_Explicit(System.Int32)~System.UInt128 -M:System.UInt128.op_Explicit(System.Int64)~System.UInt128 -M:System.UInt128.op_Explicit(System.IntPtr)~System.UInt128 -M:System.UInt128.op_Explicit(System.SByte)~System.UInt128 -M:System.UInt128.op_Explicit(System.Single)~System.UInt128 -M:System.UInt128.op_Explicit(System.UInt128)~System.Byte -M:System.UInt128.op_Explicit(System.UInt128)~System.Char -M:System.UInt128.op_Explicit(System.UInt128)~System.Decimal -M:System.UInt128.op_Explicit(System.UInt128)~System.Double -M:System.UInt128.op_Explicit(System.UInt128)~System.Half -M:System.UInt128.op_Explicit(System.UInt128)~System.Int128 -M:System.UInt128.op_Explicit(System.UInt128)~System.Int16 -M:System.UInt128.op_Explicit(System.UInt128)~System.Int32 -M:System.UInt128.op_Explicit(System.UInt128)~System.Int64 -M:System.UInt128.op_Explicit(System.UInt128)~System.IntPtr -M:System.UInt128.op_Explicit(System.UInt128)~System.SByte -M:System.UInt128.op_Explicit(System.UInt128)~System.Single -M:System.UInt128.op_Explicit(System.UInt128)~System.UInt16 -M:System.UInt128.op_Explicit(System.UInt128)~System.UInt32 -M:System.UInt128.op_Explicit(System.UInt128)~System.UInt64 -M:System.UInt128.op_Explicit(System.UInt128)~System.UIntPtr -M:System.UInt128.op_GreaterThan(System.UInt128,System.UInt128) -M:System.UInt128.op_GreaterThanOrEqual(System.UInt128,System.UInt128) -M:System.UInt128.op_Implicit(System.Byte)~System.UInt128 -M:System.UInt128.op_Implicit(System.Char)~System.UInt128 -M:System.UInt128.op_Implicit(System.UInt16)~System.UInt128 -M:System.UInt128.op_Implicit(System.UInt32)~System.UInt128 -M:System.UInt128.op_Implicit(System.UInt64)~System.UInt128 -M:System.UInt128.op_Implicit(System.UIntPtr)~System.UInt128 -M:System.UInt128.op_Increment(System.UInt128) -M:System.UInt128.op_Inequality(System.UInt128,System.UInt128) -M:System.UInt128.op_LeftShift(System.UInt128,System.Int32) -M:System.UInt128.op_LessThan(System.UInt128,System.UInt128) -M:System.UInt128.op_LessThanOrEqual(System.UInt128,System.UInt128) -M:System.UInt128.op_Modulus(System.UInt128,System.UInt128) -M:System.UInt128.op_Multiply(System.UInt128,System.UInt128) -M:System.UInt128.op_OnesComplement(System.UInt128) -M:System.UInt128.op_RightShift(System.UInt128,System.Int32) -M:System.UInt128.op_Subtraction(System.UInt128,System.UInt128) -M:System.UInt128.op_UnaryNegation(System.UInt128) -M:System.UInt128.op_UnaryPlus(System.UInt128) -M:System.UInt128.op_UnsignedRightShift(System.UInt128,System.Int32) -M:System.UInt128.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt128.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.UInt128.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt128.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt128.Parse(System.String) -M:System.UInt128.Parse(System.String,System.Globalization.NumberStyles) -M:System.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt128.Parse(System.String,System.IFormatProvider) -M:System.UInt128.PopCount(System.UInt128) -M:System.UInt128.RotateLeft(System.UInt128,System.Int32) -M:System.UInt128.RotateRight(System.UInt128,System.Int32) -M:System.UInt128.Sign(System.UInt128) -M:System.UInt128.ToString -M:System.UInt128.ToString(System.IFormatProvider) -M:System.UInt128.ToString(System.String) -M:System.UInt128.ToString(System.String,System.IFormatProvider) -M:System.UInt128.TrailingZeroCount(System.UInt128) -M:System.UInt128.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt128.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) -M:System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt128@) -M:System.UInt128.TryParse(System.ReadOnlySpan{System.Byte},System.UInt128@) -M:System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) -M:System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt128@) -M:System.UInt128.TryParse(System.ReadOnlySpan{System.Char},System.UInt128@) -M:System.UInt128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt128@) -M:System.UInt128.TryParse(System.String,System.IFormatProvider,System.UInt128@) -M:System.UInt128.TryParse(System.String,System.UInt128@) -M:System.UInt16.Clamp(System.UInt16,System.UInt16,System.UInt16) -M:System.UInt16.CompareTo(System.Object) -M:System.UInt16.CompareTo(System.UInt16) -M:System.UInt16.CreateChecked``1(``0) -M:System.UInt16.CreateSaturating``1(``0) -M:System.UInt16.CreateTruncating``1(``0) -M:System.UInt16.DivRem(System.UInt16,System.UInt16) -M:System.UInt16.Equals(System.Object) -M:System.UInt16.Equals(System.UInt16) -M:System.UInt16.GetHashCode -M:System.UInt16.GetTypeCode -M:System.UInt16.IsEvenInteger(System.UInt16) -M:System.UInt16.IsOddInteger(System.UInt16) -M:System.UInt16.IsPow2(System.UInt16) -M:System.UInt16.LeadingZeroCount(System.UInt16) -M:System.UInt16.Log2(System.UInt16) -M:System.UInt16.Max(System.UInt16,System.UInt16) -M:System.UInt16.Min(System.UInt16,System.UInt16) -M:System.UInt16.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt16.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.UInt16.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt16.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt16.Parse(System.String) -M:System.UInt16.Parse(System.String,System.Globalization.NumberStyles) -M:System.UInt16.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt16.Parse(System.String,System.IFormatProvider) -M:System.UInt16.PopCount(System.UInt16) -M:System.UInt16.RotateLeft(System.UInt16,System.Int32) -M:System.UInt16.RotateRight(System.UInt16,System.Int32) -M:System.UInt16.Sign(System.UInt16) -M:System.UInt16.ToString -M:System.UInt16.ToString(System.IFormatProvider) -M:System.UInt16.ToString(System.String) -M:System.UInt16.ToString(System.String,System.IFormatProvider) -M:System.UInt16.TrailingZeroCount(System.UInt16) -M:System.UInt16.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt16.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) -M:System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt16@) -M:System.UInt16.TryParse(System.ReadOnlySpan{System.Byte},System.UInt16@) -M:System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) -M:System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt16@) -M:System.UInt16.TryParse(System.ReadOnlySpan{System.Char},System.UInt16@) -M:System.UInt16.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@) -M:System.UInt16.TryParse(System.String,System.IFormatProvider,System.UInt16@) -M:System.UInt16.TryParse(System.String,System.UInt16@) -M:System.UInt32.Clamp(System.UInt32,System.UInt32,System.UInt32) -M:System.UInt32.CompareTo(System.Object) -M:System.UInt32.CompareTo(System.UInt32) -M:System.UInt32.CreateChecked``1(``0) -M:System.UInt32.CreateSaturating``1(``0) -M:System.UInt32.CreateTruncating``1(``0) -M:System.UInt32.DivRem(System.UInt32,System.UInt32) -M:System.UInt32.Equals(System.Object) -M:System.UInt32.Equals(System.UInt32) -M:System.UInt32.GetHashCode -M:System.UInt32.GetTypeCode -M:System.UInt32.IsEvenInteger(System.UInt32) -M:System.UInt32.IsOddInteger(System.UInt32) -M:System.UInt32.IsPow2(System.UInt32) -M:System.UInt32.LeadingZeroCount(System.UInt32) -M:System.UInt32.Log2(System.UInt32) -M:System.UInt32.Max(System.UInt32,System.UInt32) -M:System.UInt32.Min(System.UInt32,System.UInt32) -M:System.UInt32.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt32.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.UInt32.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt32.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt32.Parse(System.String) -M:System.UInt32.Parse(System.String,System.Globalization.NumberStyles) -M:System.UInt32.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt32.Parse(System.String,System.IFormatProvider) -M:System.UInt32.PopCount(System.UInt32) -M:System.UInt32.RotateLeft(System.UInt32,System.Int32) -M:System.UInt32.RotateRight(System.UInt32,System.Int32) -M:System.UInt32.Sign(System.UInt32) -M:System.UInt32.ToString -M:System.UInt32.ToString(System.IFormatProvider) -M:System.UInt32.ToString(System.String) -M:System.UInt32.ToString(System.String,System.IFormatProvider) -M:System.UInt32.TrailingZeroCount(System.UInt32) -M:System.UInt32.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt32.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) -M:System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt32@) -M:System.UInt32.TryParse(System.ReadOnlySpan{System.Byte},System.UInt32@) -M:System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) -M:System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt32@) -M:System.UInt32.TryParse(System.ReadOnlySpan{System.Char},System.UInt32@) -M:System.UInt32.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@) -M:System.UInt32.TryParse(System.String,System.IFormatProvider,System.UInt32@) -M:System.UInt32.TryParse(System.String,System.UInt32@) -M:System.UInt64.Clamp(System.UInt64,System.UInt64,System.UInt64) -M:System.UInt64.CompareTo(System.Object) -M:System.UInt64.CompareTo(System.UInt64) -M:System.UInt64.CreateChecked``1(``0) -M:System.UInt64.CreateSaturating``1(``0) -M:System.UInt64.CreateTruncating``1(``0) -M:System.UInt64.DivRem(System.UInt64,System.UInt64) -M:System.UInt64.Equals(System.Object) -M:System.UInt64.Equals(System.UInt64) -M:System.UInt64.GetHashCode -M:System.UInt64.GetTypeCode -M:System.UInt64.IsEvenInteger(System.UInt64) -M:System.UInt64.IsOddInteger(System.UInt64) -M:System.UInt64.IsPow2(System.UInt64) -M:System.UInt64.LeadingZeroCount(System.UInt64) -M:System.UInt64.Log2(System.UInt64) -M:System.UInt64.Max(System.UInt64,System.UInt64) -M:System.UInt64.Min(System.UInt64,System.UInt64) -M:System.UInt64.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt64.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.UInt64.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt64.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt64.Parse(System.String) -M:System.UInt64.Parse(System.String,System.Globalization.NumberStyles) -M:System.UInt64.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UInt64.Parse(System.String,System.IFormatProvider) -M:System.UInt64.PopCount(System.UInt64) -M:System.UInt64.RotateLeft(System.UInt64,System.Int32) -M:System.UInt64.RotateRight(System.UInt64,System.Int32) -M:System.UInt64.Sign(System.UInt64) -M:System.UInt64.ToString -M:System.UInt64.ToString(System.IFormatProvider) -M:System.UInt64.ToString(System.String) -M:System.UInt64.ToString(System.String,System.IFormatProvider) -M:System.UInt64.TrailingZeroCount(System.UInt64) -M:System.UInt64.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt64.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) -M:System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UInt64@) -M:System.UInt64.TryParse(System.ReadOnlySpan{System.Byte},System.UInt64@) -M:System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) -M:System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UInt64@) -M:System.UInt64.TryParse(System.ReadOnlySpan{System.Char},System.UInt64@) -M:System.UInt64.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@) -M:System.UInt64.TryParse(System.String,System.IFormatProvider,System.UInt64@) -M:System.UInt64.TryParse(System.String,System.UInt64@) -M:System.UIntPtr.#ctor(System.UInt32) -M:System.UIntPtr.#ctor(System.UInt64) -M:System.UIntPtr.#ctor(System.Void*) -M:System.UIntPtr.Add(System.UIntPtr,System.Int32) -M:System.UIntPtr.Clamp(System.UIntPtr,System.UIntPtr,System.UIntPtr) -M:System.UIntPtr.CompareTo(System.Object) -M:System.UIntPtr.CompareTo(System.UIntPtr) -M:System.UIntPtr.CreateChecked``1(``0) -M:System.UIntPtr.CreateSaturating``1(``0) -M:System.UIntPtr.CreateTruncating``1(``0) -M:System.UIntPtr.DivRem(System.UIntPtr,System.UIntPtr) -M:System.UIntPtr.Equals(System.Object) -M:System.UIntPtr.Equals(System.UIntPtr) -M:System.UIntPtr.get_MaxValue -M:System.UIntPtr.get_MinValue -M:System.UIntPtr.get_Size -M:System.UIntPtr.GetHashCode -M:System.UIntPtr.IsEvenInteger(System.UIntPtr) -M:System.UIntPtr.IsOddInteger(System.UIntPtr) -M:System.UIntPtr.IsPow2(System.UIntPtr) -M:System.UIntPtr.LeadingZeroCount(System.UIntPtr) -M:System.UIntPtr.Log2(System.UIntPtr) -M:System.UIntPtr.Max(System.UIntPtr,System.UIntPtr) -M:System.UIntPtr.Min(System.UIntPtr,System.UIntPtr) -M:System.UIntPtr.op_Addition(System.UIntPtr,System.Int32) -M:System.UIntPtr.op_Equality(System.UIntPtr,System.UIntPtr) -M:System.UIntPtr.op_Explicit(System.UInt32)~System.UIntPtr -M:System.UIntPtr.op_Explicit(System.UInt64)~System.UIntPtr -M:System.UIntPtr.op_Explicit(System.UIntPtr)~System.UInt32 -M:System.UIntPtr.op_Explicit(System.UIntPtr)~System.UInt64 -M:System.UIntPtr.op_Explicit(System.UIntPtr)~System.Void* -M:System.UIntPtr.op_Explicit(System.Void*)~System.UIntPtr -M:System.UIntPtr.op_Inequality(System.UIntPtr,System.UIntPtr) -M:System.UIntPtr.op_Subtraction(System.UIntPtr,System.Int32) -M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Byte},System.IFormatProvider) -M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UIntPtr.Parse(System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UIntPtr.Parse(System.String) -M:System.UIntPtr.Parse(System.String,System.Globalization.NumberStyles) -M:System.UIntPtr.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) -M:System.UIntPtr.Parse(System.String,System.IFormatProvider) -M:System.UIntPtr.PopCount(System.UIntPtr) -M:System.UIntPtr.RotateLeft(System.UIntPtr,System.Int32) -M:System.UIntPtr.RotateRight(System.UIntPtr,System.Int32) -M:System.UIntPtr.Sign(System.UIntPtr) -M:System.UIntPtr.Subtract(System.UIntPtr,System.Int32) -M:System.UIntPtr.ToPointer -M:System.UIntPtr.ToString -M:System.UIntPtr.ToString(System.IFormatProvider) -M:System.UIntPtr.ToString(System.String) -M:System.UIntPtr.ToString(System.String,System.IFormatProvider) -M:System.UIntPtr.ToUInt32 -M:System.UIntPtr.ToUInt64 -M:System.UIntPtr.TrailingZeroCount(System.UIntPtr) -M:System.UIntPtr.TryFormat(System.Span{System.Byte},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UIntPtr.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider) -M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) -M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.IFormatProvider,System.UIntPtr@) -M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Byte},System.UIntPtr@) -M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) -M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.IFormatProvider,System.UIntPtr@) -M:System.UIntPtr.TryParse(System.ReadOnlySpan{System.Char},System.UIntPtr@) -M:System.UIntPtr.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UIntPtr@) -M:System.UIntPtr.TryParse(System.String,System.IFormatProvider,System.UIntPtr@) -M:System.UIntPtr.TryParse(System.String,System.UIntPtr@) -M:System.UnauthorizedAccessException.#ctor -M:System.UnauthorizedAccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.UnauthorizedAccessException.#ctor(System.String) -M:System.UnauthorizedAccessException.#ctor(System.String,System.Exception) -M:System.UnhandledExceptionEventArgs.#ctor(System.Object,System.Boolean) -M:System.UnhandledExceptionEventArgs.get_ExceptionObject -M:System.UnhandledExceptionEventArgs.get_IsTerminating -M:System.UnhandledExceptionEventHandler.#ctor(System.Object,System.IntPtr) -M:System.UnhandledExceptionEventHandler.BeginInvoke(System.Object,System.UnhandledExceptionEventArgs,System.AsyncCallback,System.Object) -M:System.UnhandledExceptionEventHandler.EndInvoke(System.IAsyncResult) -M:System.UnhandledExceptionEventHandler.Invoke(System.Object,System.UnhandledExceptionEventArgs) -M:System.Uri.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Uri.#ctor(System.String) -M:System.Uri.#ctor(System.String,System.Boolean) -M:System.Uri.#ctor(System.String,System.UriCreationOptions@) -M:System.Uri.#ctor(System.String,System.UriKind) -M:System.Uri.#ctor(System.Uri,System.String) -M:System.Uri.#ctor(System.Uri,System.String,System.Boolean) -M:System.Uri.#ctor(System.Uri,System.Uri) -M:System.Uri.Canonicalize -M:System.Uri.CheckHostName(System.String) -M:System.Uri.CheckSchemeName(System.String) -M:System.Uri.CheckSecurity -M:System.Uri.Compare(System.Uri,System.Uri,System.UriComponents,System.UriFormat,System.StringComparison) -M:System.Uri.Equals(System.Object) -M:System.Uri.Escape -M:System.Uri.EscapeDataString(System.String) -M:System.Uri.EscapeString(System.String) -M:System.Uri.EscapeUriString(System.String) -M:System.Uri.FromHex(System.Char) -M:System.Uri.get_AbsolutePath -M:System.Uri.get_AbsoluteUri -M:System.Uri.get_Authority -M:System.Uri.get_DnsSafeHost -M:System.Uri.get_Fragment -M:System.Uri.get_Host -M:System.Uri.get_HostNameType -M:System.Uri.get_IdnHost -M:System.Uri.get_IsAbsoluteUri -M:System.Uri.get_IsDefaultPort -M:System.Uri.get_IsFile -M:System.Uri.get_IsLoopback -M:System.Uri.get_IsUnc -M:System.Uri.get_LocalPath -M:System.Uri.get_OriginalString -M:System.Uri.get_PathAndQuery -M:System.Uri.get_Port -M:System.Uri.get_Query -M:System.Uri.get_Scheme -M:System.Uri.get_Segments -M:System.Uri.get_UserEscaped -M:System.Uri.get_UserInfo -M:System.Uri.GetComponents(System.UriComponents,System.UriFormat) -M:System.Uri.GetHashCode -M:System.Uri.GetLeftPart(System.UriPartial) -M:System.Uri.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.Uri.HexEscape(System.Char) -M:System.Uri.HexUnescape(System.String,System.Int32@) -M:System.Uri.IsBadFileSystemCharacter(System.Char) -M:System.Uri.IsBaseOf(System.Uri) -M:System.Uri.IsExcludedCharacter(System.Char) -M:System.Uri.IsHexDigit(System.Char) -M:System.Uri.IsHexEncoding(System.String,System.Int32) -M:System.Uri.IsReservedCharacter(System.Char) -M:System.Uri.IsWellFormedOriginalString -M:System.Uri.IsWellFormedUriString(System.String,System.UriKind) -M:System.Uri.MakeRelative(System.Uri) -M:System.Uri.MakeRelativeUri(System.Uri) -M:System.Uri.op_Equality(System.Uri,System.Uri) -M:System.Uri.op_Inequality(System.Uri,System.Uri) -M:System.Uri.Parse -M:System.Uri.ToString -M:System.Uri.TryCreate(System.String,System.UriCreationOptions@,System.Uri@) -M:System.Uri.TryCreate(System.String,System.UriKind,System.Uri@) -M:System.Uri.TryCreate(System.Uri,System.String,System.Uri@) -M:System.Uri.TryCreate(System.Uri,System.Uri,System.Uri@) -M:System.Uri.TryFormat(System.Span{System.Char},System.Int32@) -M:System.Uri.Unescape(System.String) -M:System.Uri.UnescapeDataString(System.String) -M:System.UriBuilder.#ctor -M:System.UriBuilder.#ctor(System.String) -M:System.UriBuilder.#ctor(System.String,System.String) -M:System.UriBuilder.#ctor(System.String,System.String,System.Int32) -M:System.UriBuilder.#ctor(System.String,System.String,System.Int32,System.String) -M:System.UriBuilder.#ctor(System.String,System.String,System.Int32,System.String,System.String) -M:System.UriBuilder.#ctor(System.Uri) -M:System.UriBuilder.Equals(System.Object) -M:System.UriBuilder.get_Fragment -M:System.UriBuilder.get_Host -M:System.UriBuilder.get_Password -M:System.UriBuilder.get_Path -M:System.UriBuilder.get_Port -M:System.UriBuilder.get_Query -M:System.UriBuilder.get_Scheme -M:System.UriBuilder.get_Uri -M:System.UriBuilder.get_UserName -M:System.UriBuilder.GetHashCode -M:System.UriBuilder.set_Fragment(System.String) -M:System.UriBuilder.set_Host(System.String) -M:System.UriBuilder.set_Password(System.String) -M:System.UriBuilder.set_Path(System.String) -M:System.UriBuilder.set_Port(System.Int32) -M:System.UriBuilder.set_Query(System.String) -M:System.UriBuilder.set_Scheme(System.String) -M:System.UriBuilder.set_UserName(System.String) -M:System.UriBuilder.ToString -M:System.UriCreationOptions.get_DangerousDisablePathAndQueryCanonicalization -M:System.UriCreationOptions.set_DangerousDisablePathAndQueryCanonicalization(System.Boolean) -M:System.UriFormatException.#ctor -M:System.UriFormatException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.UriFormatException.#ctor(System.String) -M:System.UriFormatException.#ctor(System.String,System.Exception) -M:System.UriParser.#ctor -M:System.UriParser.GetComponents(System.Uri,System.UriComponents,System.UriFormat) -M:System.UriParser.InitializeAndValidate(System.Uri,System.UriFormatException@) -M:System.UriParser.IsBaseOf(System.Uri,System.Uri) -M:System.UriParser.IsKnownScheme(System.String) -M:System.UriParser.IsWellFormedOriginalString(System.Uri) -M:System.UriParser.OnNewUri -M:System.UriParser.OnRegister(System.String,System.Int32) -M:System.UriParser.Register(System.UriParser,System.String,System.Int32) -M:System.UriParser.Resolve(System.Uri,System.Uri,System.UriFormatException@) -M:System.ValueTuple.CompareTo(System.ValueTuple) -M:System.ValueTuple.Create -M:System.ValueTuple.Create``1(``0) -M:System.ValueTuple.Create``2(``0,``1) -M:System.ValueTuple.Create``3(``0,``1,``2) -M:System.ValueTuple.Create``4(``0,``1,``2,``3) -M:System.ValueTuple.Create``5(``0,``1,``2,``3,``4) -M:System.ValueTuple.Create``6(``0,``1,``2,``3,``4,``5) -M:System.ValueTuple.Create``7(``0,``1,``2,``3,``4,``5,``6) -M:System.ValueTuple.Create``8(``0,``1,``2,``3,``4,``5,``6,``7) -M:System.ValueTuple.Equals(System.Object) -M:System.ValueTuple.Equals(System.ValueTuple) -M:System.ValueTuple.GetHashCode -M:System.ValueTuple.ToString -M:System.ValueTuple`1.#ctor(`0) -M:System.ValueTuple`1.CompareTo(System.ValueTuple{`0}) -M:System.ValueTuple`1.Equals(System.Object) -M:System.ValueTuple`1.Equals(System.ValueTuple{`0}) -M:System.ValueTuple`1.GetHashCode -M:System.ValueTuple`1.ToString -M:System.ValueTuple`2.#ctor(`0,`1) -M:System.ValueTuple`2.CompareTo(System.ValueTuple{`0,`1}) -M:System.ValueTuple`2.Equals(System.Object) -M:System.ValueTuple`2.Equals(System.ValueTuple{`0,`1}) -M:System.ValueTuple`2.GetHashCode -M:System.ValueTuple`2.ToString -M:System.ValueTuple`3.#ctor(`0,`1,`2) -M:System.ValueTuple`3.CompareTo(System.ValueTuple{`0,`1,`2}) -M:System.ValueTuple`3.Equals(System.Object) -M:System.ValueTuple`3.Equals(System.ValueTuple{`0,`1,`2}) -M:System.ValueTuple`3.GetHashCode -M:System.ValueTuple`3.ToString -M:System.ValueTuple`4.#ctor(`0,`1,`2,`3) -M:System.ValueTuple`4.CompareTo(System.ValueTuple{`0,`1,`2,`3}) -M:System.ValueTuple`4.Equals(System.Object) -M:System.ValueTuple`4.Equals(System.ValueTuple{`0,`1,`2,`3}) -M:System.ValueTuple`4.GetHashCode -M:System.ValueTuple`4.ToString -M:System.ValueTuple`5.#ctor(`0,`1,`2,`3,`4) -M:System.ValueTuple`5.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4}) -M:System.ValueTuple`5.Equals(System.Object) -M:System.ValueTuple`5.Equals(System.ValueTuple{`0,`1,`2,`3,`4}) -M:System.ValueTuple`5.GetHashCode -M:System.ValueTuple`5.ToString -M:System.ValueTuple`6.#ctor(`0,`1,`2,`3,`4,`5) -M:System.ValueTuple`6.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5}) -M:System.ValueTuple`6.Equals(System.Object) -M:System.ValueTuple`6.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5}) -M:System.ValueTuple`6.GetHashCode -M:System.ValueTuple`6.ToString -M:System.ValueTuple`7.#ctor(`0,`1,`2,`3,`4,`5,`6) -M:System.ValueTuple`7.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6}) -M:System.ValueTuple`7.Equals(System.Object) -M:System.ValueTuple`7.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6}) -M:System.ValueTuple`7.GetHashCode -M:System.ValueTuple`7.ToString -M:System.ValueTuple`8.#ctor(`0,`1,`2,`3,`4,`5,`6,`7) -M:System.ValueTuple`8.CompareTo(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6,`7}) -M:System.ValueTuple`8.Equals(System.Object) -M:System.ValueTuple`8.Equals(System.ValueTuple{`0,`1,`2,`3,`4,`5,`6,`7}) -M:System.ValueTuple`8.GetHashCode -M:System.ValueTuple`8.ToString -M:System.ValueType.#ctor -M:System.ValueType.Equals(System.Object) -M:System.ValueType.GetHashCode -M:System.ValueType.ToString -M:System.Version.#ctor -M:System.Version.#ctor(System.Int32,System.Int32) -M:System.Version.#ctor(System.Int32,System.Int32,System.Int32) -M:System.Version.#ctor(System.Int32,System.Int32,System.Int32,System.Int32) -M:System.Version.#ctor(System.String) -M:System.Version.Clone -M:System.Version.CompareTo(System.Object) -M:System.Version.CompareTo(System.Version) -M:System.Version.Equals(System.Object) -M:System.Version.Equals(System.Version) -M:System.Version.get_Build -M:System.Version.get_Major -M:System.Version.get_MajorRevision -M:System.Version.get_Minor -M:System.Version.get_MinorRevision -M:System.Version.get_Revision -M:System.Version.GetHashCode -M:System.Version.op_Equality(System.Version,System.Version) -M:System.Version.op_GreaterThan(System.Version,System.Version) -M:System.Version.op_GreaterThanOrEqual(System.Version,System.Version) -M:System.Version.op_Inequality(System.Version,System.Version) -M:System.Version.op_LessThan(System.Version,System.Version) -M:System.Version.op_LessThanOrEqual(System.Version,System.Version) -M:System.Version.Parse(System.ReadOnlySpan{System.Char}) -M:System.Version.Parse(System.String) -M:System.Version.ToString -M:System.Version.ToString(System.Int32) -M:System.Version.TryFormat(System.Span{System.Byte},System.Int32,System.Int32@) -M:System.Version.TryFormat(System.Span{System.Byte},System.Int32@) -M:System.Version.TryFormat(System.Span{System.Char},System.Int32,System.Int32@) -M:System.Version.TryFormat(System.Span{System.Char},System.Int32@) -M:System.Version.TryParse(System.ReadOnlySpan{System.Char},System.Version@) -M:System.Version.TryParse(System.String,System.Version@) -M:System.WeakReference.#ctor(System.Object) -M:System.WeakReference.#ctor(System.Object,System.Boolean) -M:System.WeakReference.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.WeakReference.Finalize -M:System.WeakReference.get_IsAlive -M:System.WeakReference.get_Target -M:System.WeakReference.get_TrackResurrection -M:System.WeakReference.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.WeakReference.set_Target(System.Object) -M:System.WeakReference`1.#ctor(`0) -M:System.WeakReference`1.#ctor(`0,System.Boolean) -M:System.WeakReference`1.Finalize -M:System.WeakReference`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) -M:System.WeakReference`1.SetTarget(`0) -M:System.WeakReference`1.TryGetTarget(`0@) -T:System.AccessViolationException -T:System.Action -T:System.Action`1 -T:System.Action`10 -T:System.Action`11 -T:System.Action`12 -T:System.Action`13 -T:System.Action`14 -T:System.Action`15 -T:System.Action`16 -T:System.Action`2 -T:System.Action`3 -T:System.Action`4 -T:System.Action`5 -T:System.Action`6 -T:System.Action`7 -T:System.Action`8 -T:System.Action`9 -T:System.AggregateException -T:System.ApplicationException -T:System.ApplicationId -T:System.ArgIterator -T:System.ArgumentException -T:System.ArgumentNullException -T:System.ArgumentOutOfRangeException -T:System.ArithmeticException -T:System.Array -T:System.ArraySegment`1 -T:System.ArraySegment`1.Enumerator -T:System.ArrayTypeMismatchException -T:System.AsyncCallback -T:System.Attribute -T:System.AttributeTargets -T:System.AttributeUsageAttribute -T:System.BadImageFormatException -T:System.Base64FormattingOptions -T:System.BitConverter -T:System.Boolean -T:System.Buffer -T:System.Buffers.ArrayPool`1 -T:System.Buffers.IMemoryOwner`1 -T:System.Buffers.IPinnable -T:System.Buffers.MemoryHandle -T:System.Buffers.MemoryManager`1 -T:System.Buffers.OperationStatus -T:System.Buffers.ReadOnlySpanAction`2 -T:System.Buffers.SearchValues -T:System.Buffers.SearchValues`1 -T:System.Buffers.SpanAction`2 -T:System.Buffers.Text.Base64 -T:System.Byte -T:System.CannotUnloadAppDomainException -T:System.Char -T:System.CharEnumerator -T:System.CLSCompliantAttribute -T:System.CodeDom.Compiler.GeneratedCodeAttribute -T:System.CodeDom.Compiler.IndentedTextWriter -T:System.Collections.ArrayList -T:System.Collections.Comparer -T:System.Collections.DictionaryEntry -T:System.Collections.Generic.IAsyncEnumerable`1 -T:System.Collections.Generic.IAsyncEnumerator`1 -T:System.Collections.Generic.ICollection`1 -T:System.Collections.Generic.IComparer`1 -T:System.Collections.Generic.IDictionary`2 -T:System.Collections.Generic.IEnumerable`1 -T:System.Collections.Generic.IEnumerator`1 -T:System.Collections.Generic.IEqualityComparer`1 -T:System.Collections.Generic.IList`1 -T:System.Collections.Generic.IReadOnlyCollection`1 -T:System.Collections.Generic.IReadOnlyDictionary`2 -T:System.Collections.Generic.IReadOnlyList`1 -T:System.Collections.Generic.IReadOnlySet`1 -T:System.Collections.Generic.ISet`1 -T:System.Collections.Generic.KeyNotFoundException -T:System.Collections.Generic.KeyValuePair -T:System.Collections.Generic.KeyValuePair`2 -T:System.Collections.Hashtable -T:System.Collections.ICollection -T:System.Collections.IComparer -T:System.Collections.IDictionary -T:System.Collections.IDictionaryEnumerator -T:System.Collections.IEnumerable -T:System.Collections.IEnumerator -T:System.Collections.IEqualityComparer -T:System.Collections.IHashCodeProvider -T:System.Collections.IList -T:System.Collections.IStructuralComparable -T:System.Collections.IStructuralEquatable -T:System.Collections.ObjectModel.Collection`1 -T:System.Collections.ObjectModel.ReadOnlyCollection`1 -T:System.Collections.ObjectModel.ReadOnlyDictionary`2 -T:System.Collections.ObjectModel.ReadOnlyDictionary`2.KeyCollection -T:System.Collections.ObjectModel.ReadOnlyDictionary`2.ValueCollection -T:System.Comparison`1 -T:System.ComponentModel.DefaultValueAttribute -T:System.ComponentModel.EditorBrowsableAttribute -T:System.ComponentModel.EditorBrowsableState -T:System.Configuration.Assemblies.AssemblyHashAlgorithm -T:System.Configuration.Assemblies.AssemblyVersionCompatibility -T:System.ContextBoundObject -T:System.ContextMarshalException -T:System.ContextStaticAttribute -T:System.Convert -T:System.Converter`2 -T:System.DateOnly -T:System.DateTime -T:System.DateTimeKind -T:System.DateTimeOffset -T:System.DayOfWeek -T:System.DBNull -T:System.Decimal -T:System.Delegate -T:System.Diagnostics.CodeAnalysis.AllowNullAttribute -T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute -T:System.Diagnostics.CodeAnalysis.DisallowNullAttribute -T:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute -T:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute -T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute -T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes -T:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute -T:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute -T:System.Diagnostics.CodeAnalysis.ExperimentalAttribute -T:System.Diagnostics.CodeAnalysis.MaybeNullAttribute -T:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute -T:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute -T:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute -T:System.Diagnostics.CodeAnalysis.NotNullAttribute -T:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute -T:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute -T:System.Diagnostics.CodeAnalysis.RequiresAssemblyFilesAttribute -T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute -T:System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute -T:System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute -T:System.Diagnostics.CodeAnalysis.StringSyntaxAttribute -T:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute -T:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute -T:System.Diagnostics.CodeAnalysis.UnscopedRefAttribute -T:System.Diagnostics.ConditionalAttribute -T:System.Diagnostics.Debug -T:System.Diagnostics.Debug.AssertInterpolatedStringHandler -T:System.Diagnostics.Debug.WriteIfInterpolatedStringHandler -T:System.Diagnostics.DebuggableAttribute -T:System.Diagnostics.DebuggableAttribute.DebuggingModes -T:System.Diagnostics.DebuggerBrowsableAttribute -T:System.Diagnostics.DebuggerBrowsableState -T:System.Diagnostics.DebuggerDisplayAttribute -T:System.Diagnostics.DebuggerHiddenAttribute -T:System.Diagnostics.DebuggerNonUserCodeAttribute -T:System.Diagnostics.DebuggerStepperBoundaryAttribute -T:System.Diagnostics.DebuggerStepThroughAttribute -T:System.Diagnostics.DebuggerTypeProxyAttribute -T:System.Diagnostics.DebuggerVisualizerAttribute -T:System.Diagnostics.StackTraceHiddenAttribute -T:System.Diagnostics.Stopwatch -T:System.Diagnostics.UnreachableException -T:System.DivideByZeroException -T:System.Double -T:System.DuplicateWaitObjectException -T:System.EntryPointNotFoundException -T:System.Enum -T:System.Environment -T:System.EventArgs -T:System.EventHandler -T:System.EventHandler`1 -T:System.Exception -T:System.ExecutionEngineException -T:System.FieldAccessException -T:System.FileStyleUriParser -T:System.FlagsAttribute -T:System.FormatException -T:System.FormattableString -T:System.FtpStyleUriParser -T:System.Func`1 -T:System.Func`10 -T:System.Func`11 -T:System.Func`12 -T:System.Func`13 -T:System.Func`14 -T:System.Func`15 -T:System.Func`16 -T:System.Func`17 -T:System.Func`2 -T:System.Func`3 -T:System.Func`4 -T:System.Func`5 -T:System.Func`6 -T:System.Func`7 -T:System.Func`8 -T:System.Func`9 -T:System.GenericUriParser -T:System.GenericUriParserOptions -T:System.Globalization.Calendar -T:System.Globalization.CalendarAlgorithmType -T:System.Globalization.CalendarWeekRule -T:System.Globalization.CharUnicodeInfo -T:System.Globalization.ChineseLunisolarCalendar -T:System.Globalization.CompareInfo -T:System.Globalization.CompareOptions -T:System.Globalization.CultureInfo -T:System.Globalization.CultureNotFoundException -T:System.Globalization.CultureTypes -T:System.Globalization.DateTimeFormatInfo -T:System.Globalization.DateTimeStyles -T:System.Globalization.DaylightTime -T:System.Globalization.DigitShapes -T:System.Globalization.EastAsianLunisolarCalendar -T:System.Globalization.GlobalizationExtensions -T:System.Globalization.GregorianCalendar -T:System.Globalization.GregorianCalendarTypes -T:System.Globalization.HebrewCalendar -T:System.Globalization.HijriCalendar -T:System.Globalization.IdnMapping -T:System.Globalization.ISOWeek -T:System.Globalization.JapaneseCalendar -T:System.Globalization.JapaneseLunisolarCalendar -T:System.Globalization.JulianCalendar -T:System.Globalization.KoreanCalendar -T:System.Globalization.KoreanLunisolarCalendar -T:System.Globalization.NumberFormatInfo -T:System.Globalization.NumberStyles -T:System.Globalization.PersianCalendar -T:System.Globalization.RegionInfo -T:System.Globalization.SortKey -T:System.Globalization.SortVersion -T:System.Globalization.StringInfo -T:System.Globalization.TaiwanCalendar -T:System.Globalization.TaiwanLunisolarCalendar -T:System.Globalization.TextElementEnumerator -T:System.Globalization.TextInfo -T:System.Globalization.ThaiBuddhistCalendar -T:System.Globalization.TimeSpanStyles -T:System.Globalization.UmAlQuraCalendar -T:System.Globalization.UnicodeCategory -T:System.GopherStyleUriParser -T:System.Guid -T:System.Half -T:System.HashCode -T:System.HttpStyleUriParser -T:System.IAsyncDisposable -T:System.IAsyncResult -T:System.ICloneable -T:System.IComparable -T:System.IComparable`1 -T:System.IConvertible -T:System.ICustomFormatter -T:System.IDisposable -T:System.IEquatable`1 -T:System.IFormatProvider -T:System.IFormattable -T:System.Index -T:System.IndexOutOfRangeException -T:System.InsufficientExecutionStackException -T:System.InsufficientMemoryException -T:System.Int128 -T:System.Int16 -T:System.Int32 -T:System.Int64 -T:System.IntPtr -T:System.InvalidCastException -T:System.InvalidOperationException -T:System.InvalidProgramException -T:System.InvalidTimeZoneException -T:System.IObservable`1 -T:System.IObserver`1 -T:System.IParsable`1 -T:System.IProgress`1 -T:System.ISpanFormattable -T:System.ISpanParsable`1 -T:System.IUtf8SpanFormattable -T:System.IUtf8SpanParsable`1 -T:System.Lazy`1 -T:System.Lazy`2 -T:System.LdapStyleUriParser -T:System.Math -T:System.MathF -T:System.MemberAccessException -T:System.Memory`1 -T:System.MethodAccessException -T:System.MidpointRounding -T:System.MissingFieldException -T:System.MissingMemberException -T:System.MissingMethodException -T:System.ModuleHandle -T:System.MulticastDelegate -T:System.MulticastNotSupportedException -T:System.NetPipeStyleUriParser -T:System.NetTcpStyleUriParser -T:System.NewsStyleUriParser -T:System.NonSerializedAttribute -T:System.NotFiniteNumberException -T:System.NotImplementedException -T:System.NotSupportedException -T:System.Nullable -T:System.Nullable`1 -T:System.NullReferenceException -T:System.Numerics.BitOperations -T:System.Numerics.IAdditionOperators`3 -T:System.Numerics.IAdditiveIdentity`2 -T:System.Numerics.IBinaryFloatingPointIeee754`1 -T:System.Numerics.IBinaryInteger`1 -T:System.Numerics.IBinaryNumber`1 -T:System.Numerics.IBitwiseOperators`3 -T:System.Numerics.IComparisonOperators`3 -T:System.Numerics.IDecrementOperators`1 -T:System.Numerics.IDivisionOperators`3 -T:System.Numerics.IEqualityOperators`3 -T:System.Numerics.IExponentialFunctions`1 -T:System.Numerics.IFloatingPoint`1 -T:System.Numerics.IFloatingPointConstants`1 -T:System.Numerics.IFloatingPointIeee754`1 -T:System.Numerics.IHyperbolicFunctions`1 -T:System.Numerics.IIncrementOperators`1 -T:System.Numerics.ILogarithmicFunctions`1 -T:System.Numerics.IMinMaxValue`1 -T:System.Numerics.IModulusOperators`3 -T:System.Numerics.IMultiplicativeIdentity`2 -T:System.Numerics.IMultiplyOperators`3 -T:System.Numerics.INumber`1 -T:System.Numerics.INumberBase`1 -T:System.Numerics.IPowerFunctions`1 -T:System.Numerics.IRootFunctions`1 -T:System.Numerics.IShiftOperators`3 -T:System.Numerics.ISignedNumber`1 -T:System.Numerics.ISubtractionOperators`3 -T:System.Numerics.ITrigonometricFunctions`1 -T:System.Numerics.IUnaryNegationOperators`2 -T:System.Numerics.IUnaryPlusOperators`2 -T:System.Numerics.IUnsignedNumber`1 -T:System.Numerics.TotalOrderIeee754Comparer`1 -T:System.Object -T:System.ObjectDisposedException -T:System.ObsoleteAttribute -T:System.OperatingSystem -T:System.OperationCanceledException -T:System.OutOfMemoryException -T:System.OverflowException -T:System.ParamArrayAttribute -T:System.PlatformID -T:System.PlatformNotSupportedException -T:System.Predicate`1 -T:System.Progress`1 -T:System.Random -T:System.Range -T:System.RankException -T:System.ReadOnlyMemory`1 -T:System.ReadOnlySpan`1 -T:System.ReadOnlySpan`1.Enumerator -T:System.ResolveEventArgs -T:System.ResolveEventHandler -T:System.Runtime.CompilerServices.AccessedThroughPropertyAttribute -T:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder -T:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute -T:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute -T:System.Runtime.CompilerServices.AsyncStateMachineAttribute -T:System.Runtime.CompilerServices.AsyncTaskMethodBuilder -T:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1 -T:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder -T:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1 -T:System.Runtime.CompilerServices.AsyncVoidMethodBuilder -T:System.Runtime.CompilerServices.CallConvCdecl -T:System.Runtime.CompilerServices.CallConvFastcall -T:System.Runtime.CompilerServices.CallConvMemberFunction -T:System.Runtime.CompilerServices.CallConvStdcall -T:System.Runtime.CompilerServices.CallConvSuppressGCTransition -T:System.Runtime.CompilerServices.CallConvThiscall -T:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute -T:System.Runtime.CompilerServices.CallerFilePathAttribute -T:System.Runtime.CompilerServices.CallerLineNumberAttribute -T:System.Runtime.CompilerServices.CallerMemberNameAttribute -T:System.Runtime.CompilerServices.CollectionBuilderAttribute -T:System.Runtime.CompilerServices.CompilationRelaxations -T:System.Runtime.CompilerServices.CompilationRelaxationsAttribute -T:System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute -T:System.Runtime.CompilerServices.CompilerGeneratedAttribute -T:System.Runtime.CompilerServices.CompilerGlobalScopeAttribute -T:System.Runtime.CompilerServices.ConditionalWeakTable`2 -T:System.Runtime.CompilerServices.ConditionalWeakTable`2.CreateValueCallback -T:System.Runtime.CompilerServices.ConfiguredAsyncDisposable -T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1 -T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator -T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable -T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter -T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1 -T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter -T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable -T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter -T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1 -T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter -T:System.Runtime.CompilerServices.CustomConstantAttribute -T:System.Runtime.CompilerServices.DateTimeConstantAttribute -T:System.Runtime.CompilerServices.DecimalConstantAttribute -T:System.Runtime.CompilerServices.DefaultDependencyAttribute -T:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler -T:System.Runtime.CompilerServices.DependencyAttribute -T:System.Runtime.CompilerServices.DisablePrivateReflectionAttribute -T:System.Runtime.CompilerServices.DisableRuntimeMarshallingAttribute -T:System.Runtime.CompilerServices.DiscardableAttribute -T:System.Runtime.CompilerServices.EnumeratorCancellationAttribute -T:System.Runtime.CompilerServices.ExtensionAttribute -T:System.Runtime.CompilerServices.FixedAddressValueTypeAttribute -T:System.Runtime.CompilerServices.FixedBufferAttribute -T:System.Runtime.CompilerServices.FormattableStringFactory -T:System.Runtime.CompilerServices.IAsyncStateMachine -T:System.Runtime.CompilerServices.ICriticalNotifyCompletion -T:System.Runtime.CompilerServices.IndexerNameAttribute -T:System.Runtime.CompilerServices.InlineArrayAttribute -T:System.Runtime.CompilerServices.INotifyCompletion -T:System.Runtime.CompilerServices.InternalsVisibleToAttribute -T:System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute -T:System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute -T:System.Runtime.CompilerServices.IsByRefLikeAttribute -T:System.Runtime.CompilerServices.IsConst -T:System.Runtime.CompilerServices.IsExternalInit -T:System.Runtime.CompilerServices.IsReadOnlyAttribute -T:System.Runtime.CompilerServices.IStrongBox -T:System.Runtime.CompilerServices.IsUnmanagedAttribute -T:System.Runtime.CompilerServices.IsVolatile -T:System.Runtime.CompilerServices.IteratorStateMachineAttribute -T:System.Runtime.CompilerServices.ITuple -T:System.Runtime.CompilerServices.LoadHint -T:System.Runtime.CompilerServices.MethodCodeType -T:System.Runtime.CompilerServices.MethodImplAttribute -T:System.Runtime.CompilerServices.MethodImplOptions -T:System.Runtime.CompilerServices.ModuleInitializerAttribute -T:System.Runtime.CompilerServices.NullableAttribute -T:System.Runtime.CompilerServices.NullableContextAttribute -T:System.Runtime.CompilerServices.NullablePublicOnlyAttribute -T:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder -T:System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1 -T:System.Runtime.CompilerServices.PreserveBaseOverridesAttribute -T:System.Runtime.CompilerServices.ReferenceAssemblyAttribute -T:System.Runtime.CompilerServices.RefSafetyRulesAttribute -T:System.Runtime.CompilerServices.RequiredMemberAttribute -T:System.Runtime.CompilerServices.RequiresLocationAttribute -T:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute -T:System.Runtime.CompilerServices.RuntimeFeature -T:System.Runtime.CompilerServices.RuntimeHelpers -T:System.Runtime.CompilerServices.RuntimeHelpers.CleanupCode -T:System.Runtime.CompilerServices.RuntimeHelpers.TryCode -T:System.Runtime.CompilerServices.RuntimeWrappedException -T:System.Runtime.CompilerServices.ScopedRefAttribute -T:System.Runtime.CompilerServices.SkipLocalsInitAttribute -T:System.Runtime.CompilerServices.SpecialNameAttribute -T:System.Runtime.CompilerServices.StateMachineAttribute -T:System.Runtime.CompilerServices.StringFreezingAttribute -T:System.Runtime.CompilerServices.StrongBox`1 -T:System.Runtime.CompilerServices.SuppressIldasmAttribute -T:System.Runtime.CompilerServices.SwitchExpressionException -T:System.Runtime.CompilerServices.TaskAwaiter -T:System.Runtime.CompilerServices.TaskAwaiter`1 -T:System.Runtime.CompilerServices.TupleElementNamesAttribute -T:System.Runtime.CompilerServices.TypeForwardedFromAttribute -T:System.Runtime.CompilerServices.TypeForwardedToAttribute -T:System.Runtime.CompilerServices.Unsafe -T:System.Runtime.CompilerServices.UnsafeAccessorAttribute -T:System.Runtime.CompilerServices.UnsafeAccessorKind -T:System.Runtime.CompilerServices.UnsafeValueTypeAttribute -T:System.Runtime.CompilerServices.ValueTaskAwaiter -T:System.Runtime.CompilerServices.ValueTaskAwaiter`1 -T:System.Runtime.CompilerServices.YieldAwaitable -T:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter -T:System.RuntimeArgumentHandle -T:System.RuntimeFieldHandle -T:System.RuntimeMethodHandle -T:System.RuntimeTypeHandle -T:System.SByte -T:System.SerializableAttribute -T:System.Single -T:System.Span`1 -T:System.Span`1.Enumerator -T:System.StackOverflowException -T:System.String -T:System.StringComparer -T:System.StringComparison -T:System.StringNormalizationExtensions -T:System.StringSplitOptions -T:System.SystemException -T:System.Text.Ascii -T:System.Text.CompositeFormat -T:System.Text.Decoder -T:System.Text.DecoderExceptionFallback -T:System.Text.DecoderExceptionFallbackBuffer -T:System.Text.DecoderFallback -T:System.Text.DecoderFallbackBuffer -T:System.Text.DecoderFallbackException -T:System.Text.DecoderReplacementFallback -T:System.Text.DecoderReplacementFallbackBuffer -T:System.Text.Encoder -T:System.Text.EncoderExceptionFallback -T:System.Text.EncoderExceptionFallbackBuffer -T:System.Text.EncoderFallback -T:System.Text.EncoderFallbackBuffer -T:System.Text.EncoderFallbackException -T:System.Text.EncoderReplacementFallback -T:System.Text.EncoderReplacementFallbackBuffer -T:System.Text.Encoding -T:System.Text.EncodingInfo -T:System.Text.EncodingProvider -T:System.Text.NormalizationForm -T:System.Text.Rune -T:System.Text.StringBuilder -T:System.Text.StringBuilder.AppendInterpolatedStringHandler -T:System.Text.StringBuilder.ChunkEnumerator -T:System.Text.StringRuneEnumerator -T:System.Text.Unicode.Utf8 -T:System.Text.Unicode.Utf8.TryWriteInterpolatedStringHandler -T:System.Threading.CancellationToken -T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair -T:System.Threading.Tasks.ConfigureAwaitOptions -T:System.Threading.Tasks.Sources.IValueTaskSource -T:System.Threading.Tasks.Sources.IValueTaskSource`1 -T:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1 -T:System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags -T:System.Threading.Tasks.Sources.ValueTaskSourceStatus -T:System.Threading.Tasks.Task -T:System.Threading.Tasks.Task`1 -T:System.Threading.Tasks.TaskAsyncEnumerableExtensions -T:System.Threading.Tasks.TaskCanceledException -T:System.Threading.Tasks.TaskCompletionSource -T:System.Threading.Tasks.TaskCompletionSource`1 -T:System.Threading.Tasks.TaskContinuationOptions -T:System.Threading.Tasks.TaskCreationOptions -T:System.Threading.Tasks.TaskExtensions -T:System.Threading.Tasks.TaskSchedulerException -T:System.Threading.Tasks.TaskStatus -T:System.Threading.Tasks.TaskToAsyncResult -T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs -T:System.Threading.Tasks.ValueTask -T:System.Threading.Tasks.ValueTask`1 -T:System.TimeOnly -T:System.TimeoutException -T:System.TimeProvider -T:System.TimeSpan -T:System.TimeZone -T:System.TimeZoneInfo -T:System.TimeZoneInfo.AdjustmentRule -T:System.TimeZoneInfo.TransitionTime -T:System.TimeZoneNotFoundException -T:System.Tuple -T:System.Tuple`1 -T:System.Tuple`2 -T:System.Tuple`3 -T:System.Tuple`4 -T:System.Tuple`5 -T:System.Tuple`6 -T:System.Tuple`7 -T:System.Tuple`8 -T:System.TupleExtensions -T:System.Type -T:System.TypeAccessException -T:System.TypeCode -T:System.TypedReference -T:System.TypeInitializationException -T:System.TypeLoadException -T:System.TypeUnloadedException -T:System.UInt128 -T:System.UInt16 -T:System.UInt32 -T:System.UInt64 -T:System.UIntPtr -T:System.UnauthorizedAccessException -T:System.UnhandledExceptionEventArgs -T:System.UnhandledExceptionEventHandler -T:System.Uri -T:System.UriBuilder -T:System.UriComponents -T:System.UriCreationOptions -T:System.UriFormat -T:System.UriFormatException -T:System.UriHostNameType -T:System.UriKind -T:System.UriParser -T:System.UriPartial -T:System.ValueTuple -T:System.ValueTuple`1 -T:System.ValueTuple`2 -T:System.ValueTuple`3 -T:System.ValueTuple`4 -T:System.ValueTuple`5 -T:System.ValueTuple`6 -T:System.ValueTuple`7 -T:System.ValueTuple`8 -T:System.ValueType -T:System.Version -T:System.Void -T:System.WeakReference -T:System.WeakReference`1 \ No newline at end of file From 096de0c5d0381bd211082effe97c97670eab528a Mon Sep 17 00:00:00 2001 From: Sandy Armstrong Date: Sun, 26 Jan 2025 08:19:42 -0800 Subject: [PATCH 72/76] Always specify Image width/height for glyphs sourced from IGlyphService In VS 17.13, the editor's `IGlyphService` implementation was improved to return images from `IVsImageService2` based on the appropriate moniker. This fixes several instances of blurry 16px icons throughout the IDE. Unfortunately, some WPF components failed to specify explicit `Image` dimensions, leading to larger than expected glyphs in the UI. Additionally, these proper VS icons require theming, or else you can get black-on-black or other poor contrast scenarios. These changes add explicit dimensions to `Image`s that display glyphs from `IGlyphService`. It also uses `ThemedImageSourceConverter` to theme the images correctly. Sometimes this requires setting `ImageThemingUtilities.ImageBackgroundColor`. NOTE: `MoveStaticMembersDialog` is not themed, so I did not apply the changes necessary to theme the icon correctly. --- .../Def/CommonControls/MemberSelection.xaml | 22 +++++++++++++++++-- .../StaticMemberSelection.xaml | 4 +++- .../Def/PickMembers/PickMembersDialog.xaml | 21 +++++++++++++++--- .../MainDialog/PullMemberUpDialog.xaml | 22 +++++++++++++++++-- .../Def/ValueTracking/ValueTrackingTree.xaml | 20 ++++++++++++++++- 5 files changed, 80 insertions(+), 9 deletions(-) diff --git a/src/VisualStudio/Core/Def/CommonControls/MemberSelection.xaml b/src/VisualStudio/Core/Def/CommonControls/MemberSelection.xaml index 50efb6bda4e56..0e1684017beaa 100644 --- a/src/VisualStudio/Core/Def/CommonControls/MemberSelection.xaml +++ b/src/VisualStudio/Core/Def/CommonControls/MemberSelection.xaml @@ -5,10 +5,15 @@ xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" - xmlns:utilities="clr-namespace:Microsoft.VisualStudio.LanguageServices.Implementation.Utilities" xmlns:commoncontrols="clr-namespace:Microsoft.VisualStudio.LanguageServices.Implementation.CommonControls" + xmlns:utilities="clr-namespace:Microsoft.VisualStudio.LanguageServices.Implementation.Utilities" + xmlns:commoncontrols="clr-namespace:Microsoft.VisualStudio.LanguageServices.Implementation.CommonControls" + xmlns:platformimaging="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Imaging" + xmlns:vsutil="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Utilities" + xmlns:vs="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0" mc:Ignorable="d" xmlns:vsui="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0" xmlns:vsshell="clr-namespace:Microsoft.VisualStudio.Shell;assembly=Microsoft.VisualStudio.Shell.15.0" + platformimaging:ImageThemingUtilities.ImageBackgroundColor="{DynamicResource VsColor.ToolWindowBackground}" d:DesignHeight="450" d:DesignWidth="800"> @@ -18,6 +23,7 @@ 2, 4, 4, 2 + @@ -96,7 +102,19 @@ + Width="16" + Height="16"> + + + + + + + + + Source="{Binding Glyph}" + Width="16" + Height="16"/> + @@ -95,9 +97,22 @@ Focusable="False" AutomationProperties.AutomationId="{Binding SymbolName}"> - + + + + + + + + + diff --git a/src/VisualStudio/Core/Def/PullMemberUp/MainDialog/PullMemberUpDialog.xaml b/src/VisualStudio/Core/Def/PullMemberUp/MainDialog/PullMemberUpDialog.xaml index ab76938f5d0d4..f9aa2cc24ca60 100644 --- a/src/VisualStudio/Core/Def/PullMemberUp/MainDialog/PullMemberUpDialog.xaml +++ b/src/VisualStudio/Core/Def/PullMemberUp/MainDialog/PullMemberUpDialog.xaml @@ -3,8 +3,10 @@ x:Name="dialog" x:Class="Microsoft.VisualStudio.LanguageServices.Implementation.PullMemberUp.MainDialog.PullMemberUpDialog" x:ClassModifier="internal" + xmlns:platformimaging="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Imaging" xmlns:vs="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0" xmlns:vsshell="clr-namespace:Microsoft.VisualStudio.Shell;assembly=Microsoft.VisualStudio.Shell.15.0" + xmlns:vsutil="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Utilities" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" @@ -21,7 +23,8 @@ ShowInTaskbar="False" ResizeMode="CanResizeWithGrip" Title="{Binding ElementName=dialog, Path=PullMembersUpTitle}" - Background="{DynamicResource {x:Static vs:ThemedDialogColors.WindowPanelBrushKey}}"> + Background="{DynamicResource {x:Static vs:ThemedDialogColors.WindowPanelBrushKey}}" + platformimaging:ImageThemingUtilities.ImageBackgroundColor="{StaticResource {x:Static vsshell:VsColors.ToolWindowBackgroundKey}}"> @@ -48,6 +51,7 @@ + @@ -90,7 +94,21 @@ HorizontalAlignment="Stretch" Focusable="False" VerticalAlignment="Stretch"> - + + + + + + + + + + @@ -59,7 +64,20 @@ - + + + + + + + + + From 7fa4d1db20d60920de6ecc0eb0bba7ecc0c23712 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?= Date: Sun, 26 Jan 2025 14:12:15 -0800 Subject: [PATCH 73/76] Update rebuild test Semantic Search Refs exclusions (#76933) --- eng/test-rebuild.ps1 | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/eng/test-rebuild.ps1 b/eng/test-rebuild.ps1 index 68eeda7dfd6c9..ed0e3aa5c0273 100644 --- a/eng/test-rebuild.ps1 +++ b/eng/test-rebuild.ps1 @@ -67,7 +67,8 @@ try { # Semantic Search reference assemblies can't be reconstructed from source. # The assemblies are not marked with ReferenceAssemblyAttribute attribute. - " --exclude net9.0\GeneratedRefAssemblies\Microsoft.CodeAnalysis.dll" + + " --exclude net8.0\GeneratedRefAssemblies\Microsoft.CodeAnalysis.dll" + + " --exclude net8.0\GeneratedRefAssemblies\Microsoft.CodeAnalysis.CSharp.dll" + " --debugPath `"$ArtifactsDir/BuildValidator`"" + " --sourcePath `"$RepoRoot/`"" + From a87e11597dd2f99ed4939216cae1bf448d41a22b Mon Sep 17 00:00:00 2001 From: AlekseyTs Date: Mon, 27 Jan 2025 08:45:14 -0800 Subject: [PATCH 74/76] Move merging of partial members to an earlier phase of members construction. (#76871) Fixes #76651. Fixes #75002. Related to #76842. Related to #76870. --- .../Source/SourceMemberContainerSymbol.cs | 345 +++++++++++------- .../Source/SourcePropertySymbolBase.cs | 23 +- .../Semantics/PrimaryConstructorTests.cs | 70 +++- .../Symbol/Symbols/PartialPropertiesTests.cs | 38 ++ 4 files changed, 309 insertions(+), 167 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs index bb3ec749a0ffc..abb58e2d51de5 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs @@ -1695,6 +1695,11 @@ internal void AssertMemberExposure(Symbol member, bool forDiagnostics = false) // Backing fields for field-like events are not added to the members list. member = e; } + else if (member is FieldSymbol { AssociatedSymbol: SourcePropertySymbolBase { PartialDefinitionPart: PropertySymbol definition } implementation } && + definition.PartialImplementationPart == (object)implementation && implementation.BackingField != (object)member) + { + member = implementation; // This is a workaround for https://github.com/dotnet/roslyn/issues/76870, remove once the issue is addressed. + } var membersAndInitializers = Volatile.Read(ref _lazyMembersAndInitializers); @@ -1716,7 +1721,7 @@ internal void AssertMemberExposure(Symbol member, bool forDiagnostics = false) if (declared is object) { - if (declared.NonTypeMembers.Contains(m => m == (object)member) || declared.PrimaryConstructor == (object)member) + if (declared.NonTypeMembersWithPartialImplementations.Contains(m => m == (object)member) || declared.PrimaryConstructor == (object)member) { return; } @@ -1738,6 +1743,16 @@ internal void AssertMemberExposure(Symbol member, bool forDiagnostics = false) static bool isMemberInCompleteMemberList(MembersAndInitializers? membersAndInitializers, Symbol member) { + switch (member) + { + case MethodSymbol method: + member = method.PartialDefinitionPart ?? method; + break; + case PropertySymbol property: + member = property.PartialDefinitionPart ?? property; + break; + } + return membersAndInitializers?.NonTypeMembers.Contains(m => m == (object)member) == true; } } @@ -1756,16 +1771,12 @@ private Dictionary, ImmutableArray> GetMembersByNam { if (_lazyMembersDictionary == null) { - var diagnostics = BindingDiagnosticBag.GetInstance(); - var membersDictionary = MakeAllMembers(diagnostics); + var membersDictionary = MakeAllMembers(); if (Interlocked.CompareExchange(ref _lazyMembersDictionary, membersDictionary, null) == null) { - AddDeclarationDiagnostics(diagnostics); state.NotePartComplete(CompletionPart.Members); } - - diagnostics.Free(); } state.SpinWaitComplete(CompletionPart.Members, default(CancellationToken)); @@ -2840,7 +2851,7 @@ private static bool ContainsModifier(SyntaxTokenList modifiers, SyntaxKind modif return false; } - private Dictionary, ImmutableArray> MakeAllMembers(BindingDiagnosticBag diagnostics) + private Dictionary, ImmutableArray> MakeAllMembers() { Dictionary, ImmutableArray> membersByName; var membersAndInitializers = GetMembersAndInitializers(); @@ -2860,8 +2871,6 @@ private Dictionary, ImmutableArray> MakeAllMembers( AddNestedTypesToDictionary(membersByName, GetTypeMembersDictionary()); } - MergePartialMembers(ref membersByName, diagnostics); - return membersByName; } @@ -2887,7 +2896,7 @@ private static void AddNestedTypesToDictionary( private sealed class DeclaredMembersAndInitializersBuilder { - public ArrayBuilder NonTypeMembers = ArrayBuilder.GetInstance(); + public ArrayBuilder NonTypeMembersWithPartialImplementations = ArrayBuilder.GetInstance(); public readonly ArrayBuilder> StaticInitializers = ArrayBuilder>.GetInstance(); public readonly ArrayBuilder> InstanceInitializers = ArrayBuilder>.GetInstance(); public bool HaveIndexers; @@ -2900,7 +2909,7 @@ private sealed class DeclaredMembersAndInitializersBuilder public DeclaredMembersAndInitializers ToReadOnlyAndFree(CSharpCompilation compilation) { return new DeclaredMembersAndInitializers( - NonTypeMembers.ToImmutableAndFree(), + NonTypeMembersWithPartialImplementations.ToImmutableAndFree(), MembersAndInitializersBuilder.ToReadOnlyAndFree(StaticInitializers), MembersAndInitializersBuilder.ToReadOnlyAndFree(InstanceInitializers), HaveIndexers, @@ -2930,7 +2939,7 @@ private ref bool GetIsNullableEnabledForConstructorsAndFields(bool useStatic) public void Free() { - NonTypeMembers.Free(); + NonTypeMembersWithPartialImplementations.Free(); foreach (var group in StaticInitializers) { @@ -2948,7 +2957,7 @@ public void Free() protected sealed class DeclaredMembersAndInitializers { - public readonly ImmutableArray NonTypeMembers; + public readonly ImmutableArray NonTypeMembersWithPartialImplementations; public readonly ImmutableArray> StaticInitializers; public readonly ImmutableArray> InstanceInitializers; public readonly bool HaveIndexers; @@ -2957,6 +2966,8 @@ protected sealed class DeclaredMembersAndInitializers public readonly bool IsNullableEnabledForInstanceConstructorsAndFields; public readonly bool IsNullableEnabledForStaticConstructorsAndFields; + private ImmutableArray _lazyNonTypeMembers; + public static readonly DeclaredMembersAndInitializers UninitializedSentinel = new DeclaredMembersAndInitializers(); private DeclaredMembersAndInitializers() @@ -2964,7 +2975,7 @@ private DeclaredMembersAndInitializers() } public DeclaredMembersAndInitializers( - ImmutableArray nonTypeMembers, + ImmutableArray nonTypeMembersWithPartialImplementations, ImmutableArray> staticInitializers, ImmutableArray> instanceInitializers, bool haveIndexers, @@ -2974,14 +2985,14 @@ public DeclaredMembersAndInitializers( bool isNullableEnabledForStaticConstructorsAndFields, CSharpCompilation compilation) { - Debug.Assert(!nonTypeMembers.IsDefault); + Debug.Assert(!nonTypeMembersWithPartialImplementations.IsDefault); AssertInitializers(staticInitializers, compilation); AssertInitializers(instanceInitializers, compilation); - Debug.Assert(!nonTypeMembers.Any(static s => s is TypeSymbol)); + Debug.Assert(!nonTypeMembersWithPartialImplementations.Any(static s => s is TypeSymbol)); Debug.Assert(declarationWithParameters is object == primaryConstructor is object); - this.NonTypeMembers = nonTypeMembers; + this.NonTypeMembersWithPartialImplementations = nonTypeMembersWithPartialImplementations; this.StaticInitializers = staticInitializers; this.InstanceInitializers = instanceInitializers; this.HaveIndexers = haveIndexers; @@ -3023,6 +3034,16 @@ public static void AssertInitializers(ImmutableArray GetNonTypeMembers(SourceMemberContainerTypeSymbol container) + { + if (_lazyNonTypeMembers.IsDefault) + { + container.MergePartialMembersAndInitializeNonTypeMembers(NonTypeMembersWithPartialImplementations, ref _lazyNonTypeMembers); + } + + return _lazyNonTypeMembers; + } } private sealed class MembersAndInitializersBuilder @@ -3040,9 +3061,9 @@ public MembersAndInitializersBuilder(DeclaredMembersAndInitializers declaredMemb this.IsNullableEnabledForStaticConstructorsAndFields = declaredMembersAndInitializers.IsNullableEnabledForStaticConstructorsAndFields; } - public MembersAndInitializers ToReadOnlyAndFree(DeclaredMembersAndInitializers declaredMembers) + public MembersAndInitializers ToReadOnlyAndFree(SourceMemberContainerTypeSymbol container, DeclaredMembersAndInitializers declaredMembers) { - var nonTypeMembers = NonTypeMembers?.ToImmutableAndFree() ?? declaredMembers.NonTypeMembers; + var nonTypeMembers = NonTypeMembers?.ToImmutableAndFree() ?? declaredMembers.GetNonTypeMembers(container); var instanceInitializers = InstanceInitializersForPositionalMembers is null ? declaredMembers.InstanceInitializers @@ -3136,17 +3157,18 @@ public void AddInstanceInitializerForPositionalMembers(FieldOrPropertyInitialize InstanceInitializersForPositionalMembers.Add(initializer); } - public IReadOnlyCollection GetNonTypeMembers(DeclaredMembersAndInitializers declaredMembers) + public IReadOnlyCollection GetNonTypeMembers(SourceMemberContainerTypeSymbol container, DeclaredMembersAndInitializers declaredMembers) { - return NonTypeMembers ?? (IReadOnlyCollection)declaredMembers.NonTypeMembers; + return NonTypeMembers ?? (IReadOnlyCollection)declaredMembers.GetNonTypeMembers(container); } - public void AddNonTypeMember(Symbol member, DeclaredMembersAndInitializers declaredMembers) + public void AddNonTypeMember(SourceMemberContainerTypeSymbol container, Symbol member, DeclaredMembersAndInitializers declaredMembers) { if (NonTypeMembers is null) { - NonTypeMembers = ArrayBuilder.GetInstance(declaredMembers.NonTypeMembers.Length + 1); - NonTypeMembers.AddRange(declaredMembers.NonTypeMembers); + var declaredNonTypeMembers = declaredMembers.GetNonTypeMembers(container); + NonTypeMembers = ArrayBuilder.GetInstance(declaredNonTypeMembers.Length + 1); + NonTypeMembers.AddRange(declaredNonTypeMembers); } NonTypeMembers.Add(member); @@ -3213,7 +3235,7 @@ public void Free() return null; } - return membersAndInitializersBuilder.ToReadOnlyAndFree(declaredMembersAndInitializers); + return membersAndInitializersBuilder.ToReadOnlyAndFree(this, declaredMembersAndInitializers); DeclaredMembersAndInitializers? getDeclaredMembersAndInitializers() { @@ -3259,11 +3281,11 @@ public void Free() { case TypeKind.Struct: CheckForStructBadInitializers(builder, diagnostics); - CheckForStructDefaultConstructors(builder.NonTypeMembers, isEnum: false, diagnostics: diagnostics); + CheckForStructDefaultConstructors(builder.NonTypeMembersWithPartialImplementations, isEnum: false, diagnostics: diagnostics); break; case TypeKind.Enum: - CheckForStructDefaultConstructors(builder.NonTypeMembers, isEnum: true, diagnostics: diagnostics); + CheckForStructDefaultConstructors(builder.NonTypeMembersWithPartialImplementations, isEnum: true, diagnostics: diagnostics); break; case TypeKind.Class: @@ -3287,6 +3309,43 @@ public void Free() } } + private void MergePartialMembersAndInitializeNonTypeMembers(ImmutableArray nonTypeMembersWithPartialImplementations, ref ImmutableArray nonTypeMembers) + { + PooledDictionary, object>? partialMembersToMerge = null; + + foreach (Symbol member in nonTypeMembersWithPartialImplementations) + { + if (member.IsPartialMember()) + { + ImmutableArrayExtensions.AddToMultiValueDictionaryBuilder( + partialMembersToMerge ??= s_nameToObjectPool.Allocate(), + (member.IsIndexer() ? WellKnownMemberNames.Indexer : member.Name).AsMemory(), + member); + } + } + + if (partialMembersToMerge is null) + { + ImmutableInterlocked.InterlockedInitialize(ref nonTypeMembers, nonTypeMembersWithPartialImplementations); + return; + } + + Debug.Assert(partialMembersToMerge.Count != 0); + + var diagnostics = BindingDiagnosticBag.GetInstance(); + var nonTypeMembersBuilder = ArrayBuilder.GetInstance(nonTypeMembersWithPartialImplementations.Length); + nonTypeMembersBuilder.AddRange(nonTypeMembersWithPartialImplementations); + MergePartialMembers(partialMembersToMerge, nonTypeMembersBuilder, diagnostics); + partialMembersToMerge.Free(); + + if (ImmutableInterlocked.InterlockedInitialize(ref nonTypeMembers, nonTypeMembersBuilder.ToImmutableAndFree())) + { + AddDeclarationDiagnostics(diagnostics); + } + + diagnostics.Free(); + } + internal ImmutableArray GetSimpleProgramEntryPoints() { @@ -3375,7 +3434,7 @@ internal IEnumerable GetMethodsPossiblyCapturingPrimar var declared = Volatile.Read(ref _lazyDeclaredMembersAndInitializers); if (declared is not null && declared != DeclaredMembersAndInitializers.UninitializedSentinel) { - nonTypeMembersToCheck = declared.NonTypeMembers; + nonTypeMembersToCheck = declared.GetNonTypeMembers(this); primaryConstructor = declared.PrimaryConstructor; } else @@ -3421,7 +3480,7 @@ internal ImmutableArray GetMembersToMatchAgainstDeclarationSpan() if (declared is not null && declared != DeclaredMembersAndInitializers.UninitializedSentinel) { Debug.Assert(declared.PrimaryConstructor is not null); - return declared.NonTypeMembers; + return declared.GetNonTypeMembers(this); } else { @@ -3445,7 +3504,7 @@ internal ImmutableArray GetCandidateMembersForLookup(string name) var declared = Volatile.Read(ref _lazyDeclaredMembersAndInitializers); if (declared is not null && declared != DeclaredMembersAndInitializers.UninitializedSentinel) { - nonTypeMembersToCheck = declared.NonTypeMembers; + nonTypeMembersToCheck = declared.GetNonTypeMembers(this); primaryConstructor = declared.PrimaryConstructor; } else @@ -3537,7 +3596,7 @@ private void AddDeclaredNontypeMembers(DeclaredMembersAndInitializersBuilder bui break; case SyntaxKind.DelegateDeclaration: - SourceDelegateMethodSymbol.AddDelegateMembers(this, builder.NonTypeMembers, (DelegateDeclarationSyntax)syntax, diagnostics); + SourceDelegateMethodSymbol.AddDelegateMembers(this, builder.NonTypeMembersWithPartialImplementations, (DelegateDeclarationSyntax)syntax, diagnostics); break; case SyntaxKind.NamespaceDeclaration: @@ -3608,53 +3667,58 @@ internal Binder GetBinder(CSharpSyntaxNode syntaxNode) return this.DeclaringCompilation.GetBinder(syntaxNode); } - private void MergePartialMembers( - ref Dictionary, ImmutableArray> membersByName, + private static void MergePartialMembers( + Dictionary, object> membersByName, + ArrayBuilder nonTypeMembers, BindingDiagnosticBag diagnostics) { - var memberNames = ArrayBuilder>.GetInstance(membersByName.Count); - memberNames.AddRange(membersByName.Keys); - //key and value will be the same object var membersBySignature = new Dictionary(MemberSignatureComparer.PartialMethodsComparer); - foreach (var name in memberNames) + foreach (var pair in membersByName) { membersBySignature.Clear(); - foreach (var symbol in membersByName[name]) - { - if (!symbol.IsPartialMember()) - { - continue; - } - - if (!membersBySignature.TryGetValue(symbol, out var prev)) - { - membersBySignature.Add(symbol, symbol); - continue; - } - switch (symbol, prev) + if (pair.Value is ArrayBuilder arrayBuilder) + { + foreach (var symbol in arrayBuilder) { - case (SourceOrdinaryMethodSymbol currentMethod, SourceOrdinaryMethodSymbol prevMethod): - mergePartialMethods(ref membersByName, name, currentMethod, prevMethod, diagnostics); - break; - - case (SourcePropertySymbol currentProperty, SourcePropertySymbol prevProperty): - mergePartialProperties(ref membersByName, name, currentProperty, prevProperty, diagnostics); - break; + Debug.Assert(symbol.IsPartialMember()); - case (SourcePropertyAccessorSymbol, SourcePropertyAccessorSymbol): - break; // accessor symbols and their diagnostics are handled by processing the associated property + if (!membersBySignature.TryGetValue(symbol, out var prev)) + { + membersBySignature.Add(symbol, symbol); + continue; + } - default: - // This is an error scenario. We simply don't merge the symbols in this case and a duplicate name diagnostic is reported separately. - // One way this case can be reached is if type contains both `public partial int P { get; }` and `public partial int P_get();`. - Debug.Assert(symbol is SourceOrdinaryMethodSymbol or SourcePropertySymbol or SourcePropertyAccessorSymbol); - Debug.Assert(prev is SourceOrdinaryMethodSymbol or SourcePropertySymbol or SourcePropertyAccessorSymbol); - break; + switch (symbol, prev) + { + case (SourceOrdinaryMethodSymbol currentMethod, SourceOrdinaryMethodSymbol prevMethod): + mergePartialMethods(nonTypeMembers, currentMethod, prevMethod, diagnostics); + break; + + case (SourcePropertySymbol currentProperty, SourcePropertySymbol prevProperty): + mergePartialProperties(nonTypeMembers, currentProperty, prevProperty, diagnostics); + break; + + case (SourcePropertyAccessorSymbol, SourcePropertyAccessorSymbol): + break; // accessor symbols and their diagnostics are handled by processing the associated property + + default: + // This is an error scenario. We simply don't merge the symbols in this case and a duplicate name diagnostic is reported separately. + // One way this case can be reached is if type contains both `public partial int P { get; }` and `public partial int P_get();`. + Debug.Assert(symbol is SourceOrdinaryMethodSymbol or SourcePropertySymbol or SourcePropertyAccessorSymbol); + Debug.Assert(prev is SourceOrdinaryMethodSymbol or SourcePropertySymbol or SourcePropertyAccessorSymbol); + break; + } } } + else + { + var symbol = (Symbol)pair.Value; + Debug.Assert(symbol.IsPartialMember()); + membersBySignature.Add(symbol, symbol); + } foreach (var symbol in membersBySignature.Values) { @@ -3691,9 +3755,31 @@ private void MergePartialMembers( } } - memberNames.Free(); + foreach (var pair in membersByName) + { + if (pair.Value is ArrayBuilder arrayBuilder) + { + foreach (var symbol in arrayBuilder) + { + fixupNotMergedPartialProperty(symbol); + } + } + else + { + fixupNotMergedPartialProperty((Symbol)pair.Value); + } + } - void mergePartialMethods(ref Dictionary, ImmutableArray> membersByName, ReadOnlyMemory name, SourceOrdinaryMethodSymbol currentMethod, SourceOrdinaryMethodSymbol prevMethod, BindingDiagnosticBag diagnostics) + static void fixupNotMergedPartialProperty(Symbol symbol) + { + Debug.Assert(symbol.IsPartialMember()); + if (symbol is SourcePropertySymbol { OtherPartOfPartial: null } property) + { + property.SetMergedBackingField(property.DeclaredBackingField); + } + } + + static void mergePartialMethods(ArrayBuilder nonTypeMembers, SourceOrdinaryMethodSymbol currentMethod, SourceOrdinaryMethodSymbol prevMethod, BindingDiagnosticBag diagnostics) { if (currentMethod.IsPartialImplementation && (prevMethod.IsPartialImplementation || (prevMethod.OtherPartOfPartial is MethodSymbol otherImplementation && (object)otherImplementation != currentMethod))) @@ -3709,12 +3795,11 @@ void mergePartialMethods(ref Dictionary, ImmutableArray, ImmutableArray> membersByName, ReadOnlyMemory name, SourcePropertySymbol currentProperty, SourcePropertySymbol prevProperty, BindingDiagnosticBag diagnostics) + static void mergePartialProperties(ArrayBuilder nonTypeMembers, SourcePropertySymbol currentProperty, SourcePropertySymbol prevProperty, BindingDiagnosticBag diagnostics) { if (currentProperty.IsPartialImplementation && (prevProperty.IsPartialImplementation || (prevProperty.OtherPartOfPartial is SourcePropertySymbol otherImplementation && (object)otherImplementation != currentProperty))) @@ -3733,19 +3818,17 @@ void mergePartialProperties(ref Dictionary, ImmutableArray< diagnostics.Add(ErrorCode.ERR_PartialPropertyDuplicateInitializer, currentProperty.GetFirstLocation()); } - DuplicateMembersByNameIfCached(ref membersByName); - mergeAccessors(ref membersByName, (SourcePropertyAccessorSymbol?)currentProperty.GetMethod, (SourcePropertyAccessorSymbol?)prevProperty.GetMethod); - mergeAccessors(ref membersByName, (SourcePropertyAccessorSymbol?)currentProperty.SetMethod, (SourcePropertyAccessorSymbol?)prevProperty.SetMethod); - FixPartialProperty(ref membersByName, name, prevProperty, currentProperty); + mergeAccessors(nonTypeMembers, (SourcePropertyAccessorSymbol?)currentProperty.GetMethod, (SourcePropertyAccessorSymbol?)prevProperty.GetMethod); + mergeAccessors(nonTypeMembers, (SourcePropertyAccessorSymbol?)currentProperty.SetMethod, (SourcePropertyAccessorSymbol?)prevProperty.SetMethod); + FixPartialProperty(nonTypeMembers, prevProperty, currentProperty); } - void mergeAccessors(ref Dictionary, ImmutableArray> membersByName, SourcePropertyAccessorSymbol? currentAccessor, SourcePropertyAccessorSymbol? prevAccessor) + void mergeAccessors(ArrayBuilder nonTypeMembers, SourcePropertyAccessorSymbol? currentAccessor, SourcePropertyAccessorSymbol? prevAccessor) { if (currentAccessor is { } && prevAccessor is { }) { - var name = currentAccessor.Name.AsMemory(); var implementationAccessor = currentProperty.IsPartialDefinition ? prevAccessor : currentAccessor; - membersByName[name] = Remove(membersByName[name], implementationAccessor); + Remove(nonTypeMembers, implementationAccessor); } else if (currentAccessor is { } || prevAccessor is { }) { @@ -3766,17 +3849,8 @@ static bool hasInitializer(SourcePropertySymbol property) } } - private void DuplicateMembersByNameIfCached(ref Dictionary, ImmutableArray> membersByName) - { - if ((object)membersByName == _lazyEarlyAttributeDecodingMembersDictionary) - { - // Avoid mutating the cached dictionary and especially avoid doing this possibly on multiple threads in parallel. - membersByName = new Dictionary, ImmutableArray>(membersByName, ReadOnlyMemoryOfCharComparer.Instance); - } - } - - /// Links together the definition and implementation parts of a partial method. Returns a member list which has the implementation part removed. - private static ImmutableArray FixPartialMethod(ImmutableArray symbols, SourceOrdinaryMethodSymbol part1, SourceOrdinaryMethodSymbol part2) + /// Links together the definition and implementation parts of a partial method. Removes implementation part from . + private static void FixPartialMethod(ArrayBuilder nonTypeMembers, SourceOrdinaryMethodSymbol part1, SourceOrdinaryMethodSymbol part2) { SourceOrdinaryMethodSymbol definition; SourceOrdinaryMethodSymbol implementation; @@ -3794,11 +3868,11 @@ private static ImmutableArray FixPartialMethod(ImmutableArray sy SourceOrdinaryMethodSymbol.InitializePartialMethodParts(definition, implementation); // a partial method is represented in the member list by its definition part: - return Remove(symbols, implementation); + Remove(nonTypeMembers, implementation); } - /// Links together the definition and implementation parts of a partial property. Returns a member list which has the implementation part removed. - private static void FixPartialProperty(ref Dictionary, ImmutableArray> membersByName, ReadOnlyMemory name, SourcePropertySymbol part1, SourcePropertySymbol part2) + /// Links together the definition and implementation parts of a partial property. Removes implementation part from + private static void FixPartialProperty(ArrayBuilder nonTypeMembers, SourcePropertySymbol part1, SourcePropertySymbol part2) { SourcePropertySymbol definition; SourcePropertySymbol implementation; @@ -3816,27 +3890,28 @@ private static void FixPartialProperty(ref Dictionary, Immu if (implementation.DeclaredBackingField is { } implementationField && definition.DeclaredBackingField is { }) { - var fieldName = implementationField.Name.AsMemory(); - membersByName[fieldName] = Remove(membersByName[fieldName], implementationField); + Remove(nonTypeMembers, implementationField); } SourcePropertySymbol.InitializePartialPropertyParts(definition, implementation); // a partial property is represented in the member list by its definition part: - membersByName[name] = Remove(membersByName[name], implementation); + Remove(nonTypeMembers, implementation); } - private static ImmutableArray Remove(ImmutableArray symbols, Symbol symbol) + private static void Remove(ArrayBuilder symbols, Symbol symbol) { - var builder = ArrayBuilder.GetInstance(); - foreach (var s in symbols) + for (int i = 0; i < symbols.Count; i++) { - if (!ReferenceEquals(s, symbol)) + Symbol s = symbols[i]; + if (ReferenceEquals(s, symbol)) { - builder.Add(s); + symbols.RemoveAt(i); + return; } } - return builder.ToImmutableAndFree(); + + throw ExceptionUtilities.Unreachable(); } /// @@ -4008,7 +4083,7 @@ private void AddEnumMembers(DeclaredMembersAndInitializersBuilder result, EnumDe symbol = SourceEnumConstantSymbol.CreateImplicitValuedConstant(this, member, otherSymbol, otherSymbolOffset, diagnostics); } - result.NonTypeMembers.Add(symbol); + result.NonTypeMembersWithPartialImplementations.Add(symbol); if (valueOpt != null || otherSymbol is null) { @@ -4155,7 +4230,7 @@ private void CheckForStructBadInitializers(DeclaredMembersAndInitializersBuilder } } - if (hasInitializers && !builder.NonTypeMembers.Any(member => member is MethodSymbol { MethodKind: MethodKind.Constructor })) + if (hasInitializers && !builder.NonTypeMembersWithPartialImplementations.Any(member => member is MethodSymbol { MethodKind: MethodKind.Constructor })) { diagnostics.Add(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, GetFirstLocation()); } @@ -4166,7 +4241,7 @@ private void AddSynthesizedSimpleProgramEntryPointIfNecessary(MembersAndInitiali var simpleProgramEntryPoints = GetSimpleProgramEntryPoints(); foreach (var member in simpleProgramEntryPoints) { - builder.AddNonTypeMember(member, declaredMembersAndInitializers); + builder.AddNonTypeMember(this, member, declaredMembersAndInitializers); } } @@ -4177,7 +4252,7 @@ private void AddSynthesizedTypeMembersIfNecessary(MembersAndInitializersBuilder return; } - var membersSoFar = builder.GetNonTypeMembers(declaredMembersAndInitializers); + var membersSoFar = builder.GetNonTypeMembers(this, declaredMembersAndInitializers); var members = ArrayBuilder.GetInstance(membersSoFar.Count + 1); if (declaration.Kind is not (DeclarationKind.Record or DeclarationKind.RecordStruct)) @@ -4805,7 +4880,7 @@ private void AddSynthesizedConstructorsIfNecessary(MembersAndInitializersBuilder // CONSIDER: if this traversal becomes a bottleneck, the flags could be made outputs of the // dictionary construction process. For now, this is more encapsulated. - var membersSoFar = builder.GetNonTypeMembers(declaredMembersAndInitializers); + var membersSoFar = builder.GetNonTypeMembers(this, declaredMembersAndInitializers); foreach (var member in membersSoFar) { if (member.Kind == SymbolKind.Method) @@ -4844,7 +4919,7 @@ private void AddSynthesizedConstructorsIfNecessary(MembersAndInitializersBuilder if ((!hasParameterlessInstanceConstructor && this.IsStructType()) || (!hasInstanceConstructor && !this.IsStatic && !this.IsInterface)) { - builder.AddNonTypeMember((this.TypeKind == TypeKind.Submission) ? + builder.AddNonTypeMember(this, (this.TypeKind == TypeKind.Submission) ? new SynthesizedSubmissionConstructor(this, diagnostics) : new SynthesizedInstanceConstructor(this), declaredMembersAndInitializers); @@ -4858,15 +4933,15 @@ private void AddSynthesizedConstructorsIfNecessary(MembersAndInitializersBuilder { // Note: we don't have to put anything in the method - the binder will // do that when processing field initializers. - builder.AddNonTypeMember(new SynthesizedStaticConstructor(this), declaredMembersAndInitializers); + builder.AddNonTypeMember(this, new SynthesizedStaticConstructor(this), declaredMembersAndInitializers); } if (this.IsScriptClass) { var scriptInitializer = new SynthesizedInteractiveInitializerMethod(this, diagnostics); - builder.AddNonTypeMember(scriptInitializer, declaredMembersAndInitializers); + builder.AddNonTypeMember(this, scriptInitializer, declaredMembersAndInitializers); var scriptEntryPoint = SynthesizedEntryPointSymbol.Create(scriptInitializer, diagnostics); - builder.AddNonTypeMember(scriptEntryPoint, declaredMembersAndInitializers); + builder.AddNonTypeMember(this, scriptEntryPoint, declaredMembersAndInitializers); } static bool hasNonConstantInitializer(ImmutableArray> initializers) @@ -4882,7 +4957,7 @@ private void AddSynthesizedTupleMembersIfNecessary(MembersAndInitializersBuilder return; } - var synthesizedMembers = this.MakeSynthesizedTupleMembers(declaredMembersAndInitializers.NonTypeMembers); + var synthesizedMembers = this.MakeSynthesizedTupleMembers(declaredMembersAndInitializers.GetNonTypeMembers(this)); if (synthesizedMembers is null) { return; @@ -4890,7 +4965,7 @@ private void AddSynthesizedTupleMembersIfNecessary(MembersAndInitializersBuilder foreach (var synthesizedMember in synthesizedMembers) { - builder.AddNonTypeMember(synthesizedMember, declaredMembersAndInitializers); + builder.AddNonTypeMember(this, synthesizedMember, declaredMembersAndInitializers); } synthesizedMembers.Free(); @@ -4945,7 +5020,7 @@ private void AddNonTypeMembers( var fieldSymbol = (modifiers & DeclarationModifiers.Fixed) == 0 ? new SourceMemberFieldSymbolFromDeclarator(this, variable, modifiers, modifierErrors, diagnostics) : new SourceFixedFieldSymbol(this, variable, modifiers, modifierErrors, diagnostics); - builder.NonTypeMembers.Add(fieldSymbol); + builder.NonTypeMembersWithPartialImplementations.Add(fieldSymbol); // All fields are included in the nullable context for constructors and initializers, even fields without // initializers, to ensure warnings are reported for uninitialized non-nullable fields in NullableWalker. builder.UpdateIsNullableEnabledForConstructorsAndFields(useStatic: fieldSymbol.IsStatic, compilation, variable); @@ -4953,7 +5028,7 @@ private void AddNonTypeMembers( if (IsScriptClass) { // also gather expression-declared variables from the bracketed argument lists and the initializers - ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembers, variable, this, + ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembersWithPartialImplementations, variable, this, DeclarationModifiers.Private | (modifiers & DeclarationModifiers.Static), fieldSymbol); } @@ -4983,7 +5058,7 @@ private void AddNonTypeMembers( } var method = SourceOrdinaryMethodSymbol.CreateMethodSymbol(this, bodyBinder, methodSyntax, compilation.IsNullableAnalysisEnabledIn(methodSyntax), diagnostics); - builder.NonTypeMembers.Add(method); + builder.NonTypeMembersWithPartialImplementations.Add(method); } break; @@ -4998,7 +5073,7 @@ private void AddNonTypeMembers( bool isNullableEnabled = compilation.IsNullableAnalysisEnabledIn(constructorSyntax); var constructor = SourceConstructorSymbol.CreateConstructorSymbol(this, constructorSyntax, isNullableEnabled, diagnostics); - builder.NonTypeMembers.Add(constructor); + builder.NonTypeMembersWithPartialImplementations.Add(constructor); if (constructorSyntax.Initializer?.Kind() != SyntaxKind.ThisConstructorInitializer) { builder.UpdateIsNullableEnabledForConstructorsAndFields(useStatic: constructor.IsStatic, isNullableEnabled); @@ -5020,7 +5095,7 @@ private void AddNonTypeMembers( // when it is loaded from metadata. Perhaps we should just treat it as an Ordinary // method in such cases? var destructor = new SourceDestructorSymbol(this, destructorSyntax, compilation.IsNullableAnalysisEnabledIn(destructorSyntax), diagnostics); - builder.NonTypeMembers.Add(destructor); + builder.NonTypeMembersWithPartialImplementations.Add(destructor); } break; @@ -5034,10 +5109,10 @@ private void AddNonTypeMembers( } var property = SourcePropertySymbol.Create(this, bodyBinder, propertySyntax, diagnostics); - builder.NonTypeMembers.Add(property); + builder.NonTypeMembersWithPartialImplementations.Add(property); - AddAccessorIfAvailable(builder.NonTypeMembers, property.GetMethod); - AddAccessorIfAvailable(builder.NonTypeMembers, property.SetMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, property.GetMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, property.SetMethod); FieldSymbol? backingField = property.DeclaredBackingField; // TODO: can we leave this out of the member list? @@ -5046,7 +5121,7 @@ private void AddNonTypeMembers( // a similar manner and make the autoproperty fields private. if (backingField is { }) { - builder.NonTypeMembers.Add(backingField); + builder.NonTypeMembersWithPartialImplementations.Add(backingField); builder.UpdateIsNullableEnabledForConstructorsAndFields(useStatic: backingField.IsStatic, compilation, propertySyntax); var initializer = propertySyntax.Initializer; @@ -5055,7 +5130,7 @@ private void AddNonTypeMembers( if (IsScriptClass) { // also gather expression-declared variables from the initializer - ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembers, + ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembersWithPartialImplementations, initializer, this, DeclarationModifiers.Private | (property.IsStatic ? DeclarationModifiers.Static : 0), @@ -5088,14 +5163,14 @@ private void AddNonTypeMembers( foreach (VariableDeclaratorSyntax declarator in eventFieldSyntax.Declaration.Variables) { SourceFieldLikeEventSymbol @event = new SourceFieldLikeEventSymbol(this, bodyBinder, eventFieldSyntax.Modifiers, declarator, diagnostics); - builder.NonTypeMembers.Add(@event); + builder.NonTypeMembersWithPartialImplementations.Add(@event); FieldSymbol? associatedField = @event.AssociatedField; if (IsScriptClass) { // also gather expression-declared variables from the bracketed argument lists and the initializers - ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembers, declarator, this, + ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembersWithPartialImplementations, declarator, this, DeclarationModifiers.Private | (@event.IsStatic ? DeclarationModifiers.Static : 0), associatedField); } @@ -5123,8 +5198,8 @@ private void AddNonTypeMembers( Debug.Assert((object)@event.AddMethod != null); Debug.Assert((object)@event.RemoveMethod != null); - AddAccessorIfAvailable(builder.NonTypeMembers, @event.AddMethod); - AddAccessorIfAvailable(builder.NonTypeMembers, @event.RemoveMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, @event.AddMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, @event.RemoveMethod); } } break; @@ -5140,10 +5215,10 @@ private void AddNonTypeMembers( var @event = new SourceCustomEventSymbol(this, bodyBinder, eventSyntax, diagnostics); - builder.NonTypeMembers.Add(@event); + builder.NonTypeMembersWithPartialImplementations.Add(@event); - AddAccessorIfAvailable(builder.NonTypeMembers, @event.AddMethod); - AddAccessorIfAvailable(builder.NonTypeMembers, @event.RemoveMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, @event.AddMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, @event.RemoveMethod); Debug.Assert(@event.AssociatedField is null); } @@ -5160,9 +5235,9 @@ private void AddNonTypeMembers( var indexer = SourcePropertySymbol.Create(this, bodyBinder, indexerSyntax, diagnostics); builder.HaveIndexers = true; - builder.NonTypeMembers.Add(indexer); - AddAccessorIfAvailable(builder.NonTypeMembers, indexer.GetMethod); - AddAccessorIfAvailable(builder.NonTypeMembers, indexer.SetMethod); + builder.NonTypeMembersWithPartialImplementations.Add(indexer); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, indexer.GetMethod); + AddAccessorIfAvailable(builder.NonTypeMembersWithPartialImplementations, indexer.SetMethod); } break; @@ -5177,7 +5252,7 @@ private void AddNonTypeMembers( var method = SourceUserDefinedConversionSymbol.CreateUserDefinedConversionSymbol( this, bodyBinder, conversionOperatorSyntax, compilation.IsNullableAnalysisEnabledIn(conversionOperatorSyntax), diagnostics); - builder.NonTypeMembers.Add(method); + builder.NonTypeMembersWithPartialImplementations.Add(method); } break; @@ -5192,7 +5267,7 @@ private void AddNonTypeMembers( var method = SourceUserDefinedOperatorSymbol.CreateUserDefinedOperatorSymbol( this, bodyBinder, operatorSyntax, compilation.IsNullableAnalysisEnabledIn(operatorSyntax), diagnostics); - builder.NonTypeMembers.Add(method); + builder.NonTypeMembersWithPartialImplementations.Add(method); } break; @@ -5219,7 +5294,7 @@ private void AddNonTypeMembers( foreach (var vdecl in decl.Declaration.Variables) { // also gather expression-declared variables from the bracketed argument lists and the initializers - ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembers, vdecl, this, DeclarationModifiers.Private, + ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembersWithPartialImplementations, vdecl, this, DeclarationModifiers.Private, containingFieldOpt: null); } break; @@ -5231,7 +5306,7 @@ private void AddNonTypeMembers( case SyntaxKind.ThrowStatement: case SyntaxKind.SwitchStatement: case SyntaxKind.LockStatement: - ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembers, + ExpressionFieldFinder.FindExpressionVariables(builder.NonTypeMembersWithPartialImplementations, innerStatement, this, DeclarationModifiers.Private, diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs index ddb22a7995cba..d3fa761b0baee 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs @@ -9,6 +9,7 @@ using System.Diagnostics; using System.Globalization; using System.Linq; +using System.Runtime.CompilerServices; using System.Threading; using Microsoft.CodeAnalysis.CSharp.Emit; using Microsoft.CodeAnalysis.CSharp.Syntax; @@ -74,7 +75,7 @@ private enum Flags : ushort #nullable enable private SynthesizedBackingFieldSymbol? _lazyDeclaredBackingField; - private SynthesizedBackingFieldSymbol? _lazyMergedBackingField; + private StrongBox? _lazyMergedBackingField; protected SourcePropertySymbolBase( SourceMemberContainerTypeSymbol containingType, @@ -756,19 +757,11 @@ internal SynthesizedBackingFieldSymbol BackingField if (_lazyMergedBackingField is null) { var backingField = DeclaredBackingField; - // The property should only be used after members in the containing - // type are complete, and partial members have been merged. - if (!_containingType.AreMembersComplete) - { - // When calling through the SemanticModel, partial members are not - // necessarily merged when the containing type includes a primary - // constructor - see https://github.com/dotnet/roslyn/issues/75002. - Debug.Assert(_containingType.PrimaryConstructor is { }); - return backingField; - } - Interlocked.CompareExchange(ref _lazyMergedBackingField, backingField, null); + // The property should only be used after partial members have been merged. + Debug.Assert(!IsPartial); + Interlocked.CompareExchange(ref _lazyMergedBackingField, new StrongBox(backingField), null); } - return _lazyMergedBackingField; + return _lazyMergedBackingField.Value; } } @@ -787,8 +780,8 @@ internal SynthesizedBackingFieldSymbol? DeclaredBackingField internal void SetMergedBackingField(SynthesizedBackingFieldSymbol? backingField) { - Interlocked.CompareExchange(ref _lazyMergedBackingField, backingField, null); - Debug.Assert((object?)_lazyMergedBackingField == backingField); + Interlocked.CompareExchange(ref _lazyMergedBackingField, new StrongBox(backingField), null); + Debug.Assert((object?)_lazyMergedBackingField.Value == backingField); } private SynthesizedBackingFieldSymbol CreateBackingField() diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/PrimaryConstructorTests.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/PrimaryConstructorTests.cs index 623a2f0f15f6b..b6c2778c94988 100644 --- a/src/Compilers/CSharp/Test/Emit3/Semantics/PrimaryConstructorTests.cs +++ b/src/Compilers/CSharp/Test/Emit3/Semantics/PrimaryConstructorTests.cs @@ -19791,6 +19791,7 @@ class C(int p) } [WorkItem("https://github.com/dotnet/roslyn/issues/75002")] + [WorkItem("https://github.com/dotnet/roslyn/issues/76651")] [Fact] public void PartialMembers_01() { @@ -19812,14 +19813,49 @@ public partial void M() { } var comp = CreateCompilation([source1, source2]); var tree = comp.SyntaxTrees[0]; var model = comp.GetSemanticModel(tree); - // https://github.com/dotnet/roslyn/issues/75002: SemanticModel.GetDiagnostics() does not merge partial members. + model.GetDiagnostics().Verify(); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76651")] + public void PartialMembers_02() + { + var source1 = """ +[System.Diagnostics.CodeAnalysis.Experimental(C.P)] +class Repro +{ +} +"""; + + var source2 = """ +partial class C +{ + public static partial string P {get=>"";set{}} + public static partial string P {get;set;} +} + +namespace System.Diagnostics.CodeAnalysis +{ + [AttributeUsage(AttributeTargets.All, Inherited = false)] + public sealed class ExperimentalAttribute : Attribute + { + public ExperimentalAttribute(string diagnosticId) { } + + public string UrlFormat { get; set; } + + public string Message { get; set; } + } +} +"""; + var comp = CreateCompilation([source1, source2]); + + var tree = comp.SyntaxTrees[0]; + var model = comp.GetSemanticModel(tree, ignoreAccessibility: false); + model.GetDiagnostics().Verify( - // (2,3): error CS0121: The call is ambiguous between the following methods or properties: 'C.M()' and 'C.M()' - // c.M(); - Diagnostic(ErrorCode.ERR_AmbigCall, "M").WithArguments("C.M()", "C.M()").WithLocation(2, 3), - // (3,7): error CS0229: Ambiguity between 'C.P' and 'C.P' - // _ = c.P; - Diagnostic(ErrorCode.ERR_AmbigMember, "P").WithArguments("C.P", "C.P").WithLocation(3, 7)); + // (1,47): error CS0182: An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type + // [System.Diagnostics.CodeAnalysis.Experimental(C.P)] + Diagnostic(ErrorCode.ERR_BadAttributeArgument, "C.P").WithLocation(1, 47) + ); } [Fact] @@ -19880,14 +19916,14 @@ partial class C(int p) var comp = CreateCompilation([source1, source2], targetFramework: TargetFramework.Net80); var tree = comp.SyntaxTrees[0]; var model = comp.GetSemanticModel(tree); - // https://github.com/dotnet/roslyn/issues/75002: SemanticModel.GetDiagnostics() does not merge partial members. model.GetDiagnostics().Verify( - // (4,7): error CS0121: The call is ambiguous between the following methods or properties: 'C.M()' and 'C.M()' + // (4,5): warning CS8600: Converting null literal or possible null value to non-nullable type. // o = c.M(); - Diagnostic(ErrorCode.ERR_AmbigCall, "M").WithArguments("C.M()", "C.M()").WithLocation(4, 7), - // (5,7): error CS0229: Ambiguity between 'C.P' and 'C.P' + Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "c.M()").WithLocation(4, 5), + // (5,5): warning CS8600: Converting null literal or possible null value to non-nullable type. // o = c.P; - Diagnostic(ErrorCode.ERR_AmbigMember, "P").WithArguments("C.P", "C.P").WithLocation(5, 7)); + Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "c.P").WithLocation(5, 5) + ); } [WorkItem("https://github.com/dotnet/roslyn/issues/75002")] @@ -19916,14 +19952,14 @@ partial class C(int p) var comp = CreateCompilation([source1, source2], targetFramework: TargetFramework.Net80); var tree = comp.SyntaxTrees[0]; var model = comp.GetSemanticModel(tree); - // https://github.com/dotnet/roslyn/issues/75002: SemanticModel.GetDiagnostics() does not merge partial members. model.GetDiagnostics().Verify( - // (4,7): error CS0121: The call is ambiguous between the following methods or properties: 'C.M()' and 'C.M()' + // (4,5): warning CS8600: Converting null literal or possible null value to non-nullable type. // o = c.M(); - Diagnostic(ErrorCode.ERR_AmbigCall, "M").WithArguments("C.M()", "C.M()").WithLocation(4, 7), - // (5,7): error CS0229: Ambiguity between 'C.P' and 'C.P' + Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "c.M()").WithLocation(4, 5), + // (5,5): warning CS8600: Converting null literal or possible null value to non-nullable type. // o = c.P; - Diagnostic(ErrorCode.ERR_AmbigMember, "P").WithArguments("C.P", "C.P").WithLocation(5, 7)); + Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "c.P").WithLocation(5, 5) + ); } [Fact] diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/PartialPropertiesTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/PartialPropertiesTests.cs index eaa4ca1a170a9..6673e386e5806 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/PartialPropertiesTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/PartialPropertiesTests.cs @@ -5090,5 +5090,43 @@ partial struct S var comp = CreateCompilation(source); comp.VerifyEmitDiagnostics(); } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76842")] + public void IndexerWithName_01() + { + var source = """ + using System.Runtime.CompilerServices; + + partial struct S1 + { + public partial int this[int x] {get=>x;} + + [IndexerName("MyName")] + public partial int this[int x] {get;} + } + """; + + var comp = CreateCompilation(source); + comp.VerifyEmitDiagnostics(); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76842")] + public void IndexerWithName_02() + { + var source = """ + using System.Runtime.CompilerServices; + + partial struct S1 + { + [IndexerName("MyName")] + public partial int this[int x] {get=>x;} + + public partial int this[int x] {get;} + } + """; + + var comp = CreateCompilation(source); + comp.VerifyEmitDiagnostics(); + } } } From 010aaefa95983adccc05b6ef8ec409f12659b0e2 Mon Sep 17 00:00:00 2001 From: David Barbet Date: Mon, 27 Jan 2025 10:31:47 -0800 Subject: [PATCH 75/76] add configs for net9 branch --- eng/config/PublishData.json | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/eng/config/PublishData.json b/eng/config/PublishData.json index c53c5dc821844..3b859d2103fa7 100644 --- a/eng/config/PublishData.json +++ b/eng/config/PublishData.json @@ -281,6 +281,16 @@ "insertionTitlePrefix": "[Do not merge, please close me]", "vsMajorVersion": 17, "insertionCreateDraftPR": false + }, + "features/vscode_net9": { + "nugetKind": [ + "Shipping", + "NonShipping" + ], + "vsBranch": "main", + "insertionTitlePrefix": "[Do not merge, please close me]", + "vsMajorVersion": 17, + "insertionCreateDraftPR": true } } } From e5665513035ac895e85c78b72c6a5a81ddf9a7fc Mon Sep 17 00:00:00 2001 From: Todd Grunke Date: Mon, 27 Jan 2025 13:44:55 -0800 Subject: [PATCH 76/76] Reduce CPU costs under AnalyzerExecutor.ExecuteSyntaxNodeActions (#76894) * WIP: Reduce CPU costs under AnalyzerExecutor.ExecuteSyntaxNodeActions In the scrolling speedometer test, the Roslyn CodeAnalysis process shows about 25% of CPU spent in this method. Of that, a surprising amount of it (11.2%) is spent in ImmutableSegmentedDictionary.TryGetValue. Debugging through this code, it appears this is because that is called O(m x n) times where m is the number of nodes to analyze and n is the number of items in groupedActions.GroupedActionsByAnalyzer. Instead, add a hook into GroupedAnalyzerActions to allow a mapping of kind -> analyzers. This can be used by executeNodeActionsByKind to get a much quicker way to determine whether the analyzer can contribute for the node in question. Only publishing this early so Cyrus can take a peek, as I still need to do a bit of debugging around these changes. Once Cyrus and I think the changes have merit, I will create a test insertion and publish the speedometer results once those are available. Only if all that goes well will I promote this PR out of draft mode. * Use some existing helpers to create a dictionary with ImmutableArray values. * Early return to avoid the added array walk when not necessary * Pull in Cyrus's suggested tweaks around ToImmutableSegmentedDictionaryAndFree * ; --------- Co-authored-by: Cyrus Najmabadi --- .../EditAndContinue/PEDeltaAssemblyBuilder.cs | 2 +- .../Collections/DictionaryExtensions.cs | 13 +++++-- .../AnalyzerDriver.GroupedAnalyzerActions.cs | 37 ++++++++++++++++--- .../DiagnosticAnalyzer/AnalyzerDriver.cs | 22 ++++++++++- .../DiagnosticAnalyzer/AnalyzerExecutor.cs | 24 ++---------- 5 files changed, 67 insertions(+), 31 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs index 636dd4a119a61..c565c056a507c 100644 --- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs +++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs @@ -112,7 +112,7 @@ internal static EmitBaseline.MetadataSymbols GetOrCreateMetadataSymbols(EmitBase internal static SynthesizedTypeMaps GetSynthesizedTypesFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder) { var anonymousTypes = ImmutableSegmentedDictionary.CreateBuilder(); - var anonymousDelegatesWithIndexedNames = new Dictionary>(); + var anonymousDelegatesWithIndexedNames = PooledDictionary>.GetInstance(); var anonymousDelegates = ImmutableSegmentedDictionary.CreateBuilder(); foreach (var handle in reader.TypeDefinitions) diff --git a/src/Compilers/Core/Portable/Collections/DictionaryExtensions.cs b/src/Compilers/Core/Portable/Collections/DictionaryExtensions.cs index cb74f75739217..f3f6f224cfa57 100644 --- a/src/Compilers/Core/Portable/Collections/DictionaryExtensions.cs +++ b/src/Compilers/Core/Portable/Collections/DictionaryExtensions.cs @@ -76,7 +76,7 @@ public static bool TryAdd( } #endif - public static void AddPooled(this IDictionary> dictionary, K key, V value) + public static void AddPooled(this Dictionary> dictionary, K key, V value) where K : notnull { if (!dictionary.TryGetValue(key, out var values)) @@ -88,15 +88,22 @@ public static void AddPooled(this IDictionary> dictiona values.Add(value); } - public static ImmutableSegmentedDictionary> ToImmutableSegmentedDictionaryAndFree(this IReadOnlyDictionary> builder) + /// + /// Converts the passed in dictionary to an , where all + /// the values in the passed builder will be converted to an using . The will be freed at the end of + /// this method as well, and should not be used afterwards. + /// + public static ImmutableSegmentedDictionary> ToImmutableSegmentedDictionaryAndFree(this PooledDictionary> dictionary) where K : notnull { var result = ImmutableSegmentedDictionary.CreateBuilder>(); - foreach (var (key, values) in builder) + foreach (var (key, values) in dictionary) { result.Add(key, values.ToImmutableAndFree()); } + dictionary.Free(); return result.ToImmutable(); } } diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.GroupedAnalyzerActions.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.GroupedAnalyzerActions.cs index 04132ae8fafbe..521c4437f1a98 100644 --- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.GroupedAnalyzerActions.cs +++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.GroupedAnalyzerActions.cs @@ -5,6 +5,7 @@ using System.Collections.Immutable; using System.Diagnostics; using System.Linq; +using Microsoft.CodeAnalysis.Collections; using Microsoft.CodeAnalysis.PooledObjects; using Roslyn.Utilities; @@ -17,16 +18,25 @@ internal partial class AnalyzerDriver : AnalyzerDriver where /// private sealed class GroupedAnalyzerActions : IGroupedAnalyzerActions { - public static readonly GroupedAnalyzerActions Empty = new GroupedAnalyzerActions(ImmutableArray<(DiagnosticAnalyzer, GroupedAnalyzerActionsForAnalyzer)>.Empty, AnalyzerActions.Empty); + public static readonly GroupedAnalyzerActions Empty = new GroupedAnalyzerActions( + ImmutableArray<(DiagnosticAnalyzer, GroupedAnalyzerActionsForAnalyzer)>.Empty, + ImmutableSegmentedDictionary>.Empty, + AnalyzerActions.Empty); - private GroupedAnalyzerActions(ImmutableArray<(DiagnosticAnalyzer, GroupedAnalyzerActionsForAnalyzer)> groupedActionsAndAnalyzers, in AnalyzerActions analyzerActions) + private GroupedAnalyzerActions( + ImmutableArray<(DiagnosticAnalyzer, GroupedAnalyzerActionsForAnalyzer)> groupedActionsAndAnalyzers, + ImmutableSegmentedDictionary> analyzersByKind, + in AnalyzerActions analyzerActions) { GroupedActionsByAnalyzer = groupedActionsAndAnalyzers; AnalyzerActions = analyzerActions; + AnalyzersByKind = analyzersByKind; } public ImmutableArray<(DiagnosticAnalyzer analyzer, GroupedAnalyzerActionsForAnalyzer groupedActions)> GroupedActionsByAnalyzer { get; } + public ImmutableSegmentedDictionary> AnalyzersByKind { get; } + public AnalyzerActions AnalyzerActions { get; } public bool IsEmpty @@ -48,7 +58,8 @@ public static GroupedAnalyzerActions Create(DiagnosticAnalyzer analyzer, in Anal var groupedActions = new GroupedAnalyzerActionsForAnalyzer(analyzer, analyzerActions, analyzerActionsNeedFiltering: false); var groupedActionsAndAnalyzers = ImmutableArray<(DiagnosticAnalyzer, GroupedAnalyzerActionsForAnalyzer)>.Empty.Add((analyzer, groupedActions)); - return new GroupedAnalyzerActions(groupedActionsAndAnalyzers, in analyzerActions); + var analyzersByKind = CreateAnalyzersByKind(groupedActionsAndAnalyzers); + return new GroupedAnalyzerActions(groupedActionsAndAnalyzers, analyzersByKind, in analyzerActions); } public static GroupedAnalyzerActions Create(ImmutableArray analyzers, in AnalyzerActions analyzerActions) @@ -58,7 +69,8 @@ public static GroupedAnalyzerActions Create(ImmutableArray a var groups = analyzers.SelectAsArray( (analyzer, analyzerActions) => (analyzer, new GroupedAnalyzerActionsForAnalyzer(analyzer, analyzerActions, analyzerActionsNeedFiltering: true)), analyzerActions); - return new GroupedAnalyzerActions(groups, in analyzerActions); + var analyzersByKind = CreateAnalyzersByKind(groups); + return new GroupedAnalyzerActions(groups, analyzersByKind, in analyzerActions); } IGroupedAnalyzerActions IGroupedAnalyzerActions.Append(IGroupedAnalyzerActions igroupedAnalyzerActions) @@ -74,7 +86,22 @@ IGroupedAnalyzerActions IGroupedAnalyzerActions.Append(IGroupedAnalyzerActions i var newGroupedActions = GroupedActionsByAnalyzer.AddRange(groupedAnalyzerActions.GroupedActionsByAnalyzer); var newAnalyzerActions = AnalyzerActions.Append(groupedAnalyzerActions.AnalyzerActions); - return new GroupedAnalyzerActions(newGroupedActions, newAnalyzerActions); + var analyzersByKind = CreateAnalyzersByKind(newGroupedActions); + return new GroupedAnalyzerActions(newGroupedActions, analyzersByKind, newAnalyzerActions); + } + + private static ImmutableSegmentedDictionary> CreateAnalyzersByKind(ImmutableArray<(DiagnosticAnalyzer, GroupedAnalyzerActionsForAnalyzer)> groupedActionsAndAnalyzers) + { + var analyzersByKind = PooledDictionary>.GetInstance(); + foreach (var (analyzer, groupedActionsForAnalyzer) in groupedActionsAndAnalyzers) + { + foreach (var (kind, _) in groupedActionsForAnalyzer.NodeActionsByAnalyzerAndKind) + { + analyzersByKind.AddPooled(kind, analyzer); + } + } + + return analyzersByKind.ToImmutableSegmentedDictionaryAndFree(); } } } diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs index f3f942d2d1cfc..fa01b2f7f0e9f 100644 --- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs +++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs @@ -2611,10 +2611,26 @@ void executeNodeActions() void executeNodeActionsByKind(ArrayBuilder nodesToAnalyze, GroupedAnalyzerActions groupedActions, bool arePerSymbolActions) { + if (groupedActions.GroupedActionsByAnalyzer.Length == 0) + { + return; + } + + var analyzersForNodes = PooledHashSet.GetInstance(); + foreach (var node in nodesToAnalyze) + { + if (groupedActions.AnalyzersByKind.TryGetValue(_getKind(node), out var analyzersForKind)) + { + foreach (var analyzer in analyzersForKind) + { + analyzersForNodes.Add(analyzer); + } + } + } + foreach (var (analyzer, groupedActionsForAnalyzer) in groupedActions.GroupedActionsByAnalyzer) { - var nodeActionsByKind = groupedActionsForAnalyzer.NodeActionsByAnalyzerAndKind; - if (nodeActionsByKind.IsEmpty || !analysisScope.Contains(analyzer)) + if (!analyzersForNodes.Contains(analyzer) || !analysisScope.Contains(analyzer)) { continue; } @@ -2642,6 +2658,8 @@ void executeNodeActionsByKind(ArrayBuilder nodesToAnalyze, GroupedAn } } + analyzersForNodes.Free(); + void executeSyntaxNodeActions( DiagnosticAnalyzer analyzer, GroupedAnalyzerActionsForAnalyzer groupedActionsForAnalyzer, diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs index 17eeeb262d9b7..4b0acdd04c7d9 100644 --- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs +++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs @@ -932,19 +932,11 @@ internal static ImmutableSegmentedDictionary>.GetInstance()); - } - - actionsForKind.Add(nodeAction); + nodeActionsByKind.AddPooled(kind, nodeAction); } } - var tuples = nodeActionsByKind.Select(kvp => KeyValuePairUtil.Create(kvp.Key, kvp.Value.ToImmutableAndFree())); - var map = ImmutableSegmentedDictionary.CreateRange(tuples); - nodeActionsByKind.Free(); - return map; + return nodeActionsByKind.ToImmutableSegmentedDictionaryAndFree(); } /// @@ -1031,19 +1023,11 @@ internal static ImmutableSegmentedDictionary.GetInstance()); - } - - actionsForKind.Add(operationAction); + operationActionsByKind.AddPooled(kind, operationAction); } } - var tuples = operationActionsByKind.Select(kvp => KeyValuePairUtil.Create(kvp.Key, kvp.Value.ToImmutableAndFree())); - var map = ImmutableSegmentedDictionary.CreateRange(tuples); - operationActionsByKind.Free(); - return map; + return operationActionsByKind.ToImmutableSegmentedDictionaryAndFree(); } ///