<?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.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.GenerateNameForArgument(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax)">
            <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.SemanticModelExtensions.GenerateNameForExpression(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,System.Boolean)">
            <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.ArgumentSyntaxExtensions.DetermineParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax,Microsoft.CodeAnalysis.SemanticModel,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.ExpressionSyntaxExtensions.CastIfPossible(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax,Microsoft.CodeAnalysis.ITypeSymbol,System.Int32,Microsoft.CodeAnalysis.SemanticModel)">
            <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.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>
            <returns></returns>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.HidingTypeParameterSymbolExists(Microsoft.CodeAnalysis.ISymbol,System.Collections.Generic.List{Microsoft.CodeAnalysis.ISymbol})">
            <summary>
            Returns True if enclosingTypeParametersInsideOut contains a symbol with the same name as the candidateSymbol
            thereby saying that there exists a symbol which hides the candidate Symbol
            </summary>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.IsMemberAccessADynamicInvocation(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax,Microsoft.CodeAnalysis.SemanticModel)">
            <summary>
            Tells if the Member access is the starting part of a Dynamic Invocation
            </summary>
            <param name="memberAccess"></param>
            <param name="semanticModel"></param>
            <returns>Return true, if the member access is the starting point of a Dynamic Invocation</returns>
        </member>
        <member name="M:Microsoft.CodeAnalysis.CSharp.Extensions.ExpressionSyntaxExtensions.GetPredefinedKeywordKind(Microsoft.CodeAnalysis.SpecialType)">
            <summary>
            Returns the predefined keyword kind for a given specialtype.
            </summary>
            <param name="specialType">The 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.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.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.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.GetAllPrecedingTriviaToPreviousToken(Microsoft.CodeAnalysis.SyntaxToken)">
            <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.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 Foo() {
            #if true
            #endif
              }
            
            #if true
              void Foo() {
              }
            #endif
            
            but these return true:
            
            #if true
              void Foo() {
            #endif
              }
            
              void Foo() {
            #if true
              }
            #endif
            
            #if true
              void Foo() {
            #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.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.SyntaxNodeExtensions.ChildThatContainsPosition(Microsoft.CodeAnalysis.SyntaxNode,System.Int32,System.Int32@)">
            <summary>
            Returns child node or token that contains given position.
            </summary>
            <remarks>
            This is a copy of <see cref="M:Microsoft.CodeAnalysis.SyntaxNode.ChildThatContainsPosition(System.Int32)"/> that also returns the index of the child node.
            </remarks>
        </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 <see cref="M:Microsoft.CodeAnalysis.CSharp.Extensions.SyntaxTreeExtensions.IsInPartiallyWrittenGeneric(Microsoft.CodeAnalysis.SyntaxTree,System.Int32,System.Threading.CancellationToken)"/></remarks>
        </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="T:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources">
            <summary>
              A strongly-typed resource class, for looking up localized strings, etc.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.ResourceManager">
            <summary>
              Returns the cached ResourceManager instance used by this class.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.Culture">
            <summary>
              Overrides the current thread's CurrentUICulture property for all
              resource lookups using this strongly typed resource class.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.CannotRetrieveTheSpanOfA">
            <summary>
              Looks up a localized string similar to Cannot retrieve the Span of a null syntax reference..
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.ExpectedStringOrCharLiteral">
            <summary>
              Looks up a localized string similar to Expected string or char literal.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.ImplementInterface">
            <summary>
              Looks up a localized string similar to Implement Interface.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.NamespaceCanNotBeAddedIn">
            <summary>
              Looks up a localized string similar to Namespace can not be added in this destination..
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.NoAvailableLocationFoundTo">
            <summary>
              Looks up a localized string similar to No available location found to add statements to..
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.NodeDoesNotDescendFromRoo">
            <summary>
              Looks up a localized string similar to Node does not descend from root..
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.NodeNotInParentsChildLis">
            <summary>
              Looks up a localized string similar to Node not in parent&apos;s child list.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.OnlyAttributesConstructorI">
            <summary>
              Looks up a localized string similar to Only attributes, constructor initializers, expressions or statements can be made explicit.
            </summary>
        </member>
        <member name="P:Microsoft.CodeAnalysis.CSharp.CSharpWorkspaceResources.TriviaIsNotAssociatedWith">
            <summary>
              Looks up a localized string similar to Trivia is not associated with token.
            </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="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="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTreeFactoryServiceFactory.CSharpSyntaxTreeFactoryService.PathSyntaxReference">
            <summary>
            Represents a syntax reference that doesn't actually hold onto the 
            referenced node.  Instead, enough data is held onto so that the node
            can be recovered and returned if necessary.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTreeFactoryServiceFactory.CSharpSyntaxTreeFactoryService.NullSyntaxReference">
            <summary>
            Represents a syntax reference that was passed a null
            reference to a node. In this case, we just hold onto the
            weak tree reference and throw if any invalid properties
            are accessed.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTreeFactoryServiceFactory.CSharpSyntaxTreeFactoryService.PositionalSyntaxReference">
            <summary>
            Represents a syntax reference that doesn't actually hold onto the 
            referenced node.  Instead, enough data is held onto so that the node
            can be recovered and returned if necessary.
            </summary>
        </member>
        <member name="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTreeFactoryServiceFactory.CSharpSyntaxTreeFactoryService.RecoverableSyntaxTree">
            <summary>
            Represents a syntax tree that only has a weak reference to its 
            underlying data.  This way it can be passed around without forcing
            the underlying full tree to stay alive.  Think of it more as a 
            key that can be used to identify a tree rather than the tree itself.
            </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>
            <returns></returns>
        </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.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>
    </members>
</doc>
