OnDoc/ZZ_Signature_C/bin/Debug/Microsoft.CodeAnalysis.CSharp.Workspaces.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Microsoft.CodeAnalysis.CSharp.Workspaces</name>
    </assembly>
    <members>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Classification.ClassificationHelpers.GetClassification(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Determine the classification type for a given token.
            </summary>
            <param name="token">The token.</param>
            <returns>The correct syntactic classification for the token.</returns>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Classification.Worker">
            <summary>
            Worker is an utility class that can classify a list of tokens or a tree within a
            requested span The implementation is generic and can produce any kind of classification
            artifacts T T is normally either ClassificationSpan or a Tuple (for testing purposes) 
            and constructed via provided factory.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeGeneration.CSharpSyntaxGenerator.ShiftTrivia(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxNode)">
            <summary>
            Moves the trailing trivia from the node's previous token to the end of the node
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeGeneration.CSharpCodeGenerationHelpers.GetReuseableSyntaxNodeForSymbol``1(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.CSharp.CodeGeneration.CSharpCodeGenerationContextInfo)">
            <summary>
            Try use the existing syntax node and generate a new syntax node for the given <param name="symbol"/>.
            Note: the returned syntax node might be modified, which means its parent information might be missing.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeGeneration.CSharpSyntaxGeneratorInternal.RequiresLocalDeclarationType">
            <summary>
            C# always requires a type to be present with a local declaration.  (Even if that type is
            <c>var</c>).
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeGeneration.CSharpSyntaxGeneratorInternal.ParenthesizeLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)">
            <summary>
            Parenthesize the left hand size of a member access, invocation or element access expression
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.FindSymbols.CSharpDeclaredSymbolInfoFactoryService.GetSuffix(System.Char,System.Char,Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax})">
            <summary>
            Builds up the suffix to show for something with parameters in navigate-to.
            While it would be nice to just use the compiler SymbolDisplay API for this,
            it would be too expensive as it requires going back to Symbols (which requires
            creating compilations, etc.) in a perf sensitive area.
            
            So, instead, we just build a reasonable suffix using the pure syntax that a 
            user provided.  That means that if they wrote "Method(System.Int32 i)" we'll 
            show that as "Method(System.Int32)" not "Method(int)".  Given that this is
            actually what the user wrote, and it saves us from ever having to go back to
            symbols/compilations, this is well worth it, even if it does mean we have to
            create our own 'symbol display' logic here.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions">
            <inheritdoc cref="T:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpacingAfterMethodDeclarationName">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpacingAfterMethodDeclarationName"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceWithinMethodDeclarationParenthesis"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBetweenEmptyMethodDeclarationParentheses">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBetweenEmptyMethodDeclarationParentheses"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterMethodCallName">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterMethodCallName"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceWithinMethodCallParentheses">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceWithinMethodCallParentheses"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBetweenEmptyMethodCallParentheses">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBetweenEmptyMethodCallParentheses"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterControlFlowStatementKeyword">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterControlFlowStatementKeyword"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterCast">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterCast"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpacesIgnoreAroundVariableDeclaration">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpacesIgnoreAroundVariableDeclaration"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBeforeOpenSquareBracket">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBeforeOpenSquareBracket"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBetweenEmptySquareBrackets">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBetweenEmptySquareBrackets"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceWithinSquareBrackets">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceWithinSquareBrackets"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterColonInBaseTypeDeclaration">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterColonInBaseTypeDeclaration"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterComma">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterComma"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterDot">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterDot"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceAfterSemicolonsInForStatement"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBeforeColonInBaseTypeDeclaration">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBeforeColonInBaseTypeDeclaration"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBeforeComma">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBeforeComma"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBeforeDot">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBeforeDot"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpaceBeforeSemicolonsInForStatement"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.SpacingAroundBinaryOperator">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.SpacingAroundBinaryOperator"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.IndentBraces">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.IndentBraces"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.IndentBlock">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.IndentBlock"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.IndentSwitchSection">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.IndentSwitchSection"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.IndentSwitchCaseSection">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.IndentSwitchCaseSection"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.IndentSwitchCaseSectionWhenBlock">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.IndentSwitchCaseSectionWhenBlock"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.LabelPositioning">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.LabelPositioning"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.WrappingPreserveSingleLine">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.WrappingPreserveSingleLine"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.WrappingKeepStatementsOnSingleLine"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.NewLineForElse">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.NewLineForElse"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.NewLineForCatch">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.NewLineForCatch"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.NewLineForFinally">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.NewLineForFinally"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.NewLineForMembersInObjectInit">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.NewLineForMembersInObjectInit"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.NewLineForMembersInAnonymousTypes">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.NewLineForMembersInAnonymousTypes"/>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions.NewLineForClausesInQuery">
            <inheritdoc cref="P:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.NewLineForClausesInQuery"/>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpSyntaxFormattingService.ValidSingleOrMultiCharactersTokenKind(System.Char,Microsoft.CodeAnalysis.CSharp.SyntaxKind)">
            <summary>
            We'll autoformat on 'n', 't', 'e', only if they are the last character of the below keywords.  
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.CollectionExpressionWrappingLength">
            <summary>
            Internal option -- not exposed to editorconfig tooling via <see cref="F:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.EditorConfigOptions"/>.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.EditorConfigOptions">
            <summary>
            Options that we expect the user to set in editorconfig.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions2.UndocumentedOptions">
            <summary>
            Options that can be set via editorconfig but we do not provide tooling support.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.LabelPositionOptions.LeftMost">
            Placed in the Zeroth column of the text editor
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.LabelPositionOptions.OneLess">
            Placed at one less indent to the current context
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.LabelPositionOptions.NoIndent">
            Placed at the same indent as the current context
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.BinaryOperatorSpacingOptions.Single">
            Single Spacing
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.BinaryOperatorSpacingOptions.Ignore">
            Ignore Formatting
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Formatting.BinaryOperatorSpacingOptions.Remove">
            Remove Spacing
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Formatting.FormattingResult">
            <summary>
            this holds onto changes made by formatting engine.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpTriviaFormatter.IsVisualBasicComment(Microsoft.CodeAnalysis.SyntaxTrivia)">
            <summary>
            C# never passes a VB Comment
            </summary>
            <param name="trivia"></param>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Formatting.TriviaDataFactory">
            <summary>
            trivia factory.
            
            it will cache some commonly used trivia to reduce memory footprint and heap allocation
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Formatting.TriviaDataFactory.ComplexTrivia">
            <summary>   
            represents a general trivia between two tokens. slightly more expensive than others since it
            needs to calculate stuff unlike other cases
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Formatting.FormattingHelpers.IsOpenParenInVarDeconstructionDeclaration(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Checks whether currentToken is the opening paren of a deconstruction-declaration in var form, such as <c>var (x, y) = ...</c>
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Formatting.FormattingHelpers.IsCommaInTupleExpression(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Check whether the currentToken is a comma and is a delimiter between arguments inside a tuple expression.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Recommendations.CSharpRecommendationService.CSharpRecommendationServiceRunner">
            <summary>
            Adds user defined and predefined conversions to the unnamed recommendation set.
            </summary>
            <summary>
            Adds user defined operators to the unnamed recommendation set.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.RenameRewriter._isRenamingInStrings">
            <summary>
            Flag indicating if we should perform a rename inside string literals.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.RenameRewriter._isRenamingInComments">
            <summary>
            Flag indicating if we should perform a rename inside comment trivia.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.RenameRewriter._stringAndCommentTextSpans">
            <summary>
            A map from spans of tokens needing rename within strings or comments to an optional
            set of specific sub-spans within the token span that
            have <see cref="F:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.RenameRewriter._originalText"/> matches and should be renamed.
            If this sorted set is null, it indicates that sub-spans to rename within the token span
            are not available, and a regex match should be performed to rename
            all <see cref="F:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.RenameRewriter._originalText"/> matches within the span.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.GetExpansionTargetForLocation(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Gets the top most enclosing statement or CrefSyntax as target to call MakeExplicit on.
            It's either the enclosing statement, or if this statement is inside of a lambda expression, the enclosing
            statement of this lambda.
            </summary>
            <param name="token">The token to get the complexification target for.</param>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService.GetSemanticModelForNode(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel)">
            <summary>
            Gets the semantic model for the given node.
            If the node belongs to the syntax tree of the original semantic model, then returns originalSemanticModel.
            Otherwise, returns a speculative model.
            The assumption for the later case is that span start position of the given node in it's syntax tree is same as
            the span start of the original node in the original syntax tree.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Simplification.CSharpSimplificationService.NodesAndTokensToReduceComputer.Compute(Microsoft.CodeAnalysis.SyntaxNode,System.Func{Microsoft.CodeAnalysis.SyntaxNodeOrToken,System.Boolean})">
            <summary>
            Computes a list of nodes and tokens that need to be reduced in the given syntax root.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Simplification.CSharpInferredMemberNameReducer">
            <summary>
            Complexify makes inferred names explicit for tuple elements and anonymous type members. This
            class considers which ones of those can be simplified (after the refactoring was done).
            If the inferred name of the member matches, the explicit name (from Complexify) can be removed.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.AbstractCSharpSimplifier`2">
            <summary>
            Contains helpers used by several simplifier subclasses.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.AbstractCSharpSimplifier`2.TryGetPredefinedKeywordToken(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SpecialType)">
            <summary>
            Returns the predefined keyword kind for a given <see cref="T:Microsoft.CodeAnalysis.SpecialType"/>.
            </summary>
            <param name="specialType">The <see cref="T:Microsoft.CodeAnalysis.SpecialType"/> of this type.</param>
            <returns>The keyword kind for a given special type, or SyntaxKind.None if the type name is not a predefined type.</returns>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.ExpressionSimplifier.CandidateSymbolEqualityComparer">
            <summary>
            Compares symbols by their original definition.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.ExpressionSimplifier.IsReplacementCandidate(Microsoft.CodeAnalysis.ISymbol,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISymbol},System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISymbol})">
            <summary>
            Determines if <paramref name="speculativeSymbols"/> and <paramref name="speculativeNamespacesAndTypes"/>
            together contain a superset of the symbols in <paramref name="actualSymbol"/>.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.ExpressionSimplifier.IsNonRemovablePartOfDynamicMethodInvocation(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax,System.Threading.CancellationToken)">
            <summary>
            Tells if the member access is dynamically invoked and cannot be reduced. In the case of
            <c>NS1.NS2.T1.T2.Method(...dynamic...)</c> we can only remove the <c>NS1.NS2</c>
            portion. The namespace part is not encoded into the IL, but the specific types in
            <c>T1.T2</c> and cannot be removed.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.NameSimplifier.IsPartOfNamespaceDeclarationName(Microsoft.CodeAnalysis.SyntaxNode)">
            <summary>
            Checks if the SyntaxNode is a name of a namespace declaration. To be a namespace name, the syntax
            must be parented by an namespace declaration and the node itself must be equal to the declaration's Name
            property.
            </summary>
            <param name="node"></param>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers.CastSimplifier">
            <summary>
            By default the cast simplifier operates under several main principles:
            <list type="number">
            <item>The final type that a cast-expression was converted to should be the same as the final
            type that the underlying expression should convert to without the cast.  This tells us that 
            the compiler thinks that value should convert to that type implicitly, not just explicitly.</item>
            <item>Static semantics of the code should remain the same.  This means that things like overload
            resolution of the invocations the casted expression is contained within should not change.</item>
            <item>Runtime types and values should not observably change.  This means that if casting the 
            value would cause a different type to be seen in a <see cref="M:System.Object.GetType"/> call, 
            or a different value could be observed at runtime, then it must remain.</item>
            </list>
            
            These rules serve as a good foundational intuition about when casts should be kept and when 
            they should be removable.  However, they are not entirely complete.  There are cases when we
            can weaken some of the above rules if it would not be observable at runtime.  For example,
            if it can be proven that calling through an interface method would lead to the exact same
            call at runtime to a specific implementation of that interface method, then it can be legal to
            remove such a cast as at runtime this would not be observable.  This does in effect mean that
            the emitted IL will be different, but this matches the user expectation that the *end* behavior
            of their code remains the same.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTreeFactoryService.ParsedSyntaxTree">
            <summary>
            Parsed <see cref="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree"/> that creates <see cref="T:Microsoft.CodeAnalysis.Text.SourceText"/> with given encoding and checksum algorithm.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.CodeStyle.CSharpCodeStyleOptions.EditorConfigOptions">
            <summary>
            Options that we expect the user to set in editorconfig.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle.TypeStyleHelper.IsTypeApparentInAssignmentExpression(Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle.UseVarPreference,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.ITypeSymbol,System.Threading.CancellationToken)">
            <summary>
            Analyzes if type information is obvious to the reader by simply looking at the assignment expression.
            </summary>
            <remarks>
            <paramref name="typeInDeclaration"/> accepts null, to be able to cater to codegen features
            that are about to generate a local declaration and do not have this information to pass in.
            Things (like analyzers) that do have a local declaration already, should pass this in.
            </remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle.TypeStyleHelper.IsPossibleCreationMethod(Microsoft.CodeAnalysis.IMethodSymbol,Microsoft.CodeAnalysis.ITypeSymbol,Microsoft.CodeAnalysis.INamedTypeSymbol)">
            <summary>
            Looks for types that have static methods that return the same type as the container.
            e.g: int.Parse, XElement.Load, Tuple.Create etc.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle.TypeStyleHelper.IsPossibleConversionMethod(Microsoft.CodeAnalysis.IMethodSymbol)">
            <summary>
            If we have a method ToXXX and its return type is also XXX, then type name is apparent
            e.g: Convert.ToString.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.EmbeddedLanguages.VirtualChars.CSharpVirtualCharService.TryConvertMultiLineRawStringToVirtualChars(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean)">
            <summary>
            Creates the sequence for the <b>content</b> characters in this <paramref name="token"/>.  This will not
            include indentation whitespace that the language specifies is not part of the content.
            </summary>
            <param name="parentExpression">The containing expression for this token.  This is needed so that we can
            determine the indentation whitespace based on the last line of the containing multiline literal.</param>
            <param name="tokenIncludeDelimiters">If this token includes the quote (<c>"</c>) characters for the
            delimiters inside of it or not.  If so, then those quotes will need to be skipped when determining the
            content</param>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ArgumentSyntaxExtensions.DetermineParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax,Microsoft.CodeAnalysis.SemanticModel,System.Boolean,System.Boolean,System.Threading.CancellationToken)">
            <summary>
            Returns the parameter to which this argument is passed. If <paramref name="allowParams"/>
            is true, the last parameter will be returned if it is params parameter and the index of
            the specified argument is greater than the number of parameters.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.AttributeArgumentSyntaxExtensions.DetermineParameter(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax,Microsoft.CodeAnalysis.SemanticModel,System.Boolean,System.Boolean,System.Threading.CancellationToken)">
            <summary>
            Returns the parameter to which this argument is passed. If <paramref name="allowParams"/>
            is true, the last parameter will be returned if it is params parameter and the index of
            the specified argument is greater than the number of parameters.
            </summary>
            <remarks>
            Returns null if the <paramref name="argument"/> is a named argument.
            </remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery.SyntaxTreeExtensions.IsPossibleTupleContext(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.SyntaxToken,System.Int32)">
            <summary>
            Are you possibly typing a tuple type or expression?
            This is used to suppress colon as a completion trigger (so that you can type element names).
            This is also used to recommend some keywords (like var).
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery.SyntaxTreeExtensions.IsPossibleDeconstructionDesignation(Microsoft.CodeAnalysis.SyntaxTree,System.Int32,System.Threading.CancellationToken)">
            <summary>
            Are you possibly in the designation part of a deconstruction?
            This is used to enter suggestion mode (suggestions become soft-selected).
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery.SyntaxTreeExtensions.UnwrapPossibleTuple(Microsoft.CodeAnalysis.SyntaxNode)">
            <summary>
            If inside a parenthesized or tuple expression, unwrap the nestings and return the container.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery.CSharpSyntaxContext.IsAwaitStatementContext(System.Int32,System.Threading.CancellationToken)">
            <summary>
            Is this a possible position for an await statement (`await using` or `await foreach`)?
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery.CSharpSyntaxContext.ComputeIsAwaitKeywordContext(System.Int32,Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.SyntaxToken,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Determines whether await should be suggested in a given position.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.IsInRefContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SyntaxNode@)">
            <summary>
            Returns true if this expression is in some <c>ref</c> keyword context.  If <see langword="true"/> then
            <paramref name="refParent"/> will be the node containing the <see langword="ref"/> keyword.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.IsExpressionOfArgumentInDeconstruction(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)">
             <summary>
             If this declaration or identifier is part of a deconstruction, find the deconstruction.
             If found, returns either an assignment expression or a foreach variable statement.
             Returns null otherwise.
            
             copied from SyntaxExtensions.GetContainingDeconstruction
             </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.CastIfPossible(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.SemanticModel,System.Threading.CancellationToken)">
            <summary>
            Adds to <paramref name="targetType"/> if it does not contain an anonymous
            type and binds to the same type at the given <paramref name="position"/>.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.ShouldNameExpressionBeTreatedAsExpressionInsteadOfType(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SymbolInfo@,Microsoft.CodeAnalysis.ITypeSymbol@)">
            <summary>
            DeterminesCheck if we're in an interesting situation like this:
            <code>
                int i = 5;
                i.          // -- here
                List ml = new List();
            </code>
            The problem is that "i.List" gets parsed as a type.  In this case we need to try binding again as if "i" is
            an expression and not a type.  In order to do that, we need to speculate as to what 'i' meant if it wasn't
            part of a local declaration's type.
            <para/>
            Another interesting case is something like:
            <code>
                 stringList.
                 await Test2();
            </code>
            Here "stringList.await" is thought of as the return type of a local function.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ITypeSymbolExtensions.GenerateExpressionSyntax(Microsoft.CodeAnalysis.ITypeSymbol,System.Boolean)">
            <paramref name="nameSyntax"><see langword="true"/> if only normal name-syntax nodes should be returned.
            <see langword="false"/> if special nodes (like predefined types) can be used.</paramref>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.AddGlobalAlias(Microsoft.CodeAnalysis.INamespaceOrTypeSymbol,Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax)">
            <summary>
            We always unilaterally add "global::" to all named types/namespaces.  This
            will then be trimmed off if possible by the simplifier.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Extensions.OperatorPrecedence">
            <summary>
            Operator precedence classes from section 7.3.1 of the C# language specification.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SemanticModelExtensions.DecomposeName(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax@,System.String@,System.Int32@)">
            <summary>
            Decomposes a name or member access expression into its component parts.
            </summary>
            <param name="expression">The name or member access expression.</param>
            <param name="qualifier">The qualifier (or left-hand-side) of the name expression. This may be null if there is no qualifier.</param>
            <param name="name">The name of the expression.</param>
            <param name="arity">The number of generic type parameters.</param>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SemanticModelExtensions.GenerateNameForExpression(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean,System.Threading.CancellationToken)">
            <summary>
            Given an expression node, tries to generate an appropriate name that can be used for
            that expression. 
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SemanticModelExtensions.UnifiesNativeIntegers(Microsoft.CodeAnalysis.SemanticModel)">
            <summary>
            Returns whether or not <see cref="T:System.IntPtr"/> and <see cref="T:System.UIntPtr"/> are exactly identical to <see
            cref="T:System.IntPtr"/> and <see cref="T:System.UIntPtr"/> respectively.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SemanticModelExtensions.GenerateNameForArgument(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax,System.Threading.CancellationToken)">
            <summary>
            Given an argument node, tries to generate an appropriate name that can be used for that
            argument.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxKindExtensions.Contains(Microsoft.CodeAnalysis.CSharp.SyntaxKind[],Microsoft.CodeAnalysis.CSharp.SyntaxKind)">
            <summary>
            Determine if the given <see cref="T:Microsoft.CodeAnalysis.CSharp.SyntaxKind"/> array contains the given kind.
            </summary>
            <param name="kinds">Array to search</param>
            <param name="kind">Sought value</param>
            <returns>True if <paramref name = "kinds"/> contains the value<paramref name= "kind"/>.</returns>
            <remarks>PERF: Not using Array.IndexOf here because it results in a call to IndexOf on the
            default EqualityComparer for SyntaxKind.The default comparer for SyntaxKind is the
            ObjectEqualityComparer which results in boxing allocations.</remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.GetAllPrecedingTriviaToPreviousToken(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.Text.SourceText,System.Boolean)">
            <summary>
            Returns all of the trivia to the left of this token up to the previous token (concatenates
            the previous token's trailing trivia and this token's leading trivia).
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.GetRootConditionalAccessExpression(Microsoft.CodeAnalysis.SyntaxNode)">
            <summary>
            <inheritdoc cref="M:Microsoft.CodeAnalysis.LanguageService.ISyntaxFacts.GetRootConditionalAccessExpression(Microsoft.CodeAnalysis.SyntaxNode)"/>
            </summary>>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.GetEnclosingUsingDirectives(Microsoft.CodeAnalysis.SyntaxNode)">
            <summary>
            Returns the list of using directives that affect <paramref name="node"/>. The list will be returned in
            top down order.  
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.ContainsInterleavedDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken)">
            <summary>
            Returns true if the passed in node contains an interleaved pp directive.
            
            i.e. The following returns false:
            
              void Goo() {
            #if true
            #endif
              }
            
            #if true
              void Goo() {
              }
            #endif
            
            but these return true:
            
            #if true
              void Goo() {
            #endif
              }
            
              void Goo() {
            #if true
              }
            #endif
            
            #if true
              void Goo() {
            #else
              }
            #endif
            
            i.e. the method returns true if it contains a PP directive that belongs to a grouping
            constructs (like #if/#endif or #region/#endregion), but the grouping construct isn't
            entirely contained within the span of the node.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.ContainsInterleavedDirective(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Text.TextSpan,System.Threading.CancellationToken)">
            <summary>
            Similar to <see cref="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.ContainsInterleavedDirective(Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken)"/> except that the span to check
            for interleaved directives can be specified separately to the node passed in.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxNodeExtensions.SplitNodesOnPreprocessorBoundaries``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">
            <summary>
            Breaks up the list of provided nodes, based on how they are interspersed with pp
            directives, into groups.  Within these groups nodes can be moved around safely, without
            breaking any pp constructs.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxTokenExtensions.CouldBeKeyword(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Returns true if this token is something that looks like a C# keyword. This includes 
            actual keywords, contextual keywords, and even 'var' and 'dynamic'
            </summary>
            <param name="token"></param>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxTokenExtensions.IsFirstTokenOnLine(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.Text.SourceText)">
            <summary>
            Determines whether the given SyntaxToken is the first token on a line in the specified SourceText.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxTokenExtensions.GetAllTrailingTrivia(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Retrieves all trivia after this token, including it's trailing trivia and
            the leading trivia of the next token.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxTokenExtensions.FindLastTokenOfPartialGenericName(Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Lexically, find the last token that looks like it's part of this generic name.
            </summary>
            <param name="genericIdentifier">The "name" of the generic identifier, last token before
            the "&amp;"</param>
            <returns>The last token in the name</returns>
            <remarks>This is related to the code in SyntaxTreeExtensions.IsInPartiallyWrittenGeneric</remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxTriviaListExtensions.TakeRange(Microsoft.CodeAnalysis.SyntaxTriviaList,System.Int32,System.Int32)">
            <summary>
            Takes an INCLUSIVE range of trivia from the trivia list. 
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.TypeSyntaxExtensions.IsTypeInferred(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.SemanticModel)">
            <summary>
            Determines whether the specified TypeSyntax is actually 'var'.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.BasePropertyDeclarationSyntaxExtensions.TryGetSemicolonToken(Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax)">
            <summary>
            Available if <paramref name="node"/> is <see cref="T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax"/> or <see cref="T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax"/>.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.BasePropertyDeclarationSyntaxExtensions.TryWithSemicolonToken(Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax,Microsoft.CodeAnalysis.SyntaxToken)">
            <summary>
            Available if <paramref name="node"/> is <see cref="T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax"/> or <see cref="T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax"/>.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.BasePropertyDeclarationSyntaxExtensions.TryWithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax)">
            <summary>
            Available if <paramref name="node"/> is <see cref="T:Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax"/> or <see cref="T:Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax"/>.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Shared.Extensions.LanguageVersionExtensions.CSharpNext">
            <remarks>
            Corresponds to Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.CSharpNext.
            </remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.CSharpSemanticFacts.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxToken,System.Threading.CancellationToken)">
            <summary>
            Returns the best symbols found that the provided token binds to.  This is similar to <see
            cref="M:Microsoft.CodeAnalysis.ModelExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.SyntaxNode,System.Threading.CancellationToken)"/>, but sometimes employs
            heuristics to provide a better result for tokens that users conceptually think bind to things, but which the
            compiler does not necessarily return results for.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Utilities.FormattingRangeHelper">
            <summary>
            this help finding a range of tokens to format based on given ending token
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Utilities.SpeculationAnalyzer">
            <summary>
            Helper class to analyze the semantic effects of a speculated syntax node replacement on the parenting nodes.
            Given an expression node from a syntax tree and a new expression from a different syntax tree,
            it replaces the expression with the new expression to create a speculated syntax tree.
            It uses the original tree's semantic model to create a speculative semantic model and verifies that
            the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.SpeculationAnalyzer.#ctor(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SemanticModel,System.Threading.CancellationToken,System.Boolean,System.Boolean)">
            <summary>
            Creates a semantic analyzer for speculative syntax replacement.
            </summary>
            <param name="expression">Original expression to be replaced.</param>
            <param name="newExpression">New expression to replace the original expression.</param>
            <param name="semanticModel">Semantic model of <paramref name="expression"/> node's syntax tree.</param>
            <param name="cancellationToken">Cancellation token.</param>
            <param name="skipVerificationForReplacedNode">
            True if semantic analysis should be skipped for the replaced node and performed starting from parent of the original and replaced nodes.
            This could be the case when custom verifications are required to be done by the caller or
            semantics of the replaced expression are different from the original expression.
            </param>
            <param name="failOnOverloadResolutionFailuresInOriginalCode">
            True if semantic analysis should fail when any of the invocation expression ancestors of <paramref name="expression"/> in original code has overload resolution failures.
            </param>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.SpeculationAnalyzer.ReplacementChangesSemanticsOfUnchangedLambda(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)">
            <summary>
            Determines whether performing the syntax replacement in one of the sibling nodes of the given lambda expressions will change the lambda binding semantics.
            This is done by first determining the lambda parameters whose type differs in the replaced lambda node.
            For each of these parameters, we find the descendant identifier name nodes in the lambda body and check if semantics of any of the parenting nodes of these
            identifier nodes have changed in the replaced lambda.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.SpeculationAnalyzer.ReplacementBreaksBoxingInConditionalExpression(Microsoft.CodeAnalysis.TypeInfo,Microsoft.CodeAnalysis.TypeInfo,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)">
            <summary>
            Checks if the conversion might change the resultant boxed type.
            Similar boxing checks are performed elsewhere, but in this case we need to perform the check on the entire conditional expression.
            This will make sure the resultant cast is proper for the type of the conditional expression.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Utilities.TypeStyleResult.IsStylePreferred">
            <summary>
            Whether or not converting would transition the code to the style the user prefers. i.e. if the user likes
            <c>var</c> for everything, and you have <c>int i = 0</c> then <see cref="F:Microsoft.CodeAnalysis.CSharp.Utilities.TypeStyleResult.IsStylePreferred"/> will be
            <see langword="true"/>. However, if the user likes <c>var</c> for everything and you have <c>var i = 0</c>,
            then it's still possible to convert that, it would just be <see langword="false"/> for
            <see cref="F:Microsoft.CodeAnalysis.CSharp.Utilities.TypeStyleResult.IsStylePreferred"/> because it goes against the user's preferences.
            </summary>
            <remarks>
            <para>In general, most features should only convert the type if <see cref="F:Microsoft.CodeAnalysis.CSharp.Utilities.TypeStyleResult.IsStylePreferred"/> is
            <see langword="true"/>. The one exception is the refactoring, which is explicitly there to still let people
            convert things quickly, even if it's going against their stated style.</para>
            </remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.CSharpTypeStyleHelper.State.IsTypeApparentInDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle.UseVarPreference,System.Threading.CancellationToken)">
            <summary>
            Returns true if type information could be gleaned by simply looking at the given statement.
            This typically means that the type name occurs in right hand side of an assignment.
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.CSharpTypeStyleHelper.State.IsPredefinedTypeInDeclaration(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SemanticModel)">
            <summary>
            checks if the type represented by the given symbol is one of the
            simple types defined in the compiler.
            </summary>
            <remarks>
            From the IDE perspective, we also include object and string to be simplified
            to var. <see cref="M:Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPredefinedType(Microsoft.CodeAnalysis.CSharp.SyntaxKind)"/> considers string
            and object but the compiler's implementation of IsIntrinsicType does not.
            </remarks>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.CSharpTypeStyleHelper.State.IsMadeOfSpecialTypes(Microsoft.CodeAnalysis.ITypeSymbol)">
            <summary>
            Returns true for type that are arrays/nullable/pointer types of special types
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.CSharpUseExplicitTypeHelper.AssignmentSupportsStylePreference(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Simplification.CSharpSimplifierOptions,System.Threading.CancellationToken)">
            <summary>
            Analyzes the assignment expression and rejects a given declaration if it is unsuitable for explicit typing.
            </summary>
            <returns>
            false, if explicit typing cannot be used.
            true, otherwise.
            </returns>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Utilities.CSharpUseImplicitTypeHelper.AssignmentSupportsStylePreference(Microsoft.CodeAnalysis.SyntaxToken,Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Simplification.CSharpSimplifierOptions,System.Threading.CancellationToken)">
            <summary>
            Analyzes the assignment expression and rejects a given declaration if it is unsuitable for implicit typing.
            </summary>
            <returns>
            false, if implicit typing cannot be used.
            true, otherwise.
            </returns>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.Editing.CSharpImportAdder.ConflictFinder">
            <summary>
            Walks the portion of the tree we're adding imports to looking to see if those imports could likely cause
            conflicts with existing code.  Note: this is a best-effort basis, and the goal is to catch reasonable
            conflicts effectively.  There may be cases that do slip through that we can adjust for in the future.  Those
            cases should be assessed to see how reasonable/likely they are.  I.e. if it's just a hypothetical case with
            no users being hit, then that's far less important than if we have a reasonable coding pattern that would be
            impacted by adding an import to a normal namespace.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Editing.CSharpImportAdder.ConflictFinder._importedTypes">
            <summary>
            A mapping containing the simple names and arity of all imported types, mapped to the import that they're
            brought in by.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CSharp.Editing.CSharpImportAdder.ConflictFinder._importedExtensionMethods">
            <summary>
            A mapping containing the simple names of all imported extension methods, mapped to the import that
            they're brought in by.  This doesn't keep track of arity because methods can be called with type
            arguments.
            </summary>
            <remarks>
            We could consider adding more information here (for example the min/max number of args that this can be
            called with).  That could then be used to check if there could be a conflict. However, that's likely
            more complexity than we need currently.  But it is always something we can do in the future.
            </remarks>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.Only_attributes_constructor_initializers_expressions_or_statements_can_be_made_explicit">
            <summary>Only attributes, constructor initializers, expressions or statements can be made explicit</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.Implement_Interface">
            <summary>Implement Interface</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.Remove_and_Sort_Usings">
            <summary>R&amp;emove and Sort Usings</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.Sort_Usings">
            <summary>&amp;Sort Usings</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.CSharp_Formatting_Rules">
            <summary>C# Formatting Rules</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.CSharp_Coding_Conventions">
            <summary>C# Coding Conventions</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.var_preferences">
            <summary>var preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Expression_bodied_members">
            <summary>Expression-bodied members</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Pattern_matching_preferences">
            <summary>Pattern matching preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Null_checking_preferences">
            <summary>Null-checking preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Code_block_preferences">
            <summary>Code-block preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.using_directive_preferences">
            <summary>'using' directive preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Expected_string_or_char_literal">
            <summary>Expected string or char literal</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.EditorConfig_option_0_contains_unrecognized_value_1">
            <summary>EditorConfig option '{0}' contains unrecognized value '{1}'</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Indentation_preferences">
            <summary>Indentation preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Space_preferences">
            <summary>Space preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpCompilerExtensionsResources.Wrapping_preferences">
            <summary>Wrapping preferences</summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceExtensionsResources.EmptyResource">
            <summary>Remove this value when another is added.</summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CodeStyle.PreferBracesPreference">
            <summary>
            Defines the known values for <see cref="F:Microsoft.CodeAnalysis.CSharp.CodeStyle.CSharpCodeStyleOptions.PreferBraces"/>.
            </summary>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CodeStyle.PreferBracesPreference.None">
            <summary>
            Braces are allowed, but not preferred.
            </summary>
            <remarks>
            <para>The value <c>0</c> is important for serialization compatibility in
            <see cref="M:Microsoft.CodeAnalysis.CodeStyle.CodeStyleOption2`1.FromXElement(System.Xml.Linq.XElement)"/>. Prior to the use of this enum, the serialized value
            was the <see cref="T:System.Boolean"/> value <see langword="false"/>.</para>
            </remarks>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CodeStyle.PreferBracesPreference.Always">
             <summary>
             <para>Braces are preferred where allowed except in the following limited situations:</para>
            
             <list type="bullet">
             <item><description>Braces are not required for the embedded statement of an <c>else</c> clause when the embedded statement is an <c>if</c> statement.</description></item>
             <item><description>In a sequence of consecutive <c>using</c> statements, only the last statement requires braces.</description></item>
             <item><description>In a sequence of consecutive <c>lock</c> statements, only the last statement requires braces.</description></item>
             <item><description>In a sequence of consecutive <c>fixed</c> statements, only the last statement requires braces.</description></item>
             </list>
             </summary>
             <remarks>
             <para>The value <c>1</c> is important for serialization compatibility in
             <see cref="M:Microsoft.CodeAnalysis.CodeStyle.CodeStyleOption2`1.FromXElement(System.Xml.Linq.XElement)"/>. Prior to the use of this enum, the serialized value
             was the <see cref="T:System.Boolean"/> value <see langword="true"/>.</para>
             </remarks>
        </member>
        <member name="F:Microsoft.CodeAnalysis.CodeStyle.PreferBracesPreference.WhenMultiline">
             <summary>
             <para>Braces are always allowed, and generally preferred except in limited situations involving single-line
             statements and expressions:</para>
            
             <list type="bullet">
             <item><description>Braces may be omitted in the cases described for <see cref="F:Microsoft.CodeAnalysis.CodeStyle.PreferBracesPreference.Always"/>.</description></item>
             <item><description>Braces may be omitted when the entire statement is placed on one line.</description></item>
             <item><description>For a statement that contains one or more embedded statements, braces may be omitted when
             every embedded statement fits on one line, and the part preceding the embedded statement is placed on one
             line. If any embedded statement uses braces, braces are preferred for all embedded statements of the same
             parent statement. For the purposes of evaluating this rule, if the embedded statement following an
             <c>else</c> keyword is an if statement, the embedded statements of the nested if statement are treated as
             children of the parent statement of the <c>else</c> keyword.</description></item>
             </list>
             </summary>
        </member>
    </members>
</doc>