<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ICSharpCode.NRefactory.CSharp</name>
    </assembly>
    <members>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNode">
            <summary>
            Represents a node in the control flow graph of a C# method.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.None">
            <summary>
            Unknown node type
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.StartNode">
            <summary>
            Node in front of a statement
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.BetweenStatements">
            <summary>
            Node between two statements
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.EndNode">
            <summary>
            Node at the end of a statement list
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.LoopCondition">
            <summary>
            Node representing the position before evaluating the condition of a loop.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdge.IsLeavingTryFinally">
            <summary>
            Gets whether this control flow edge is leaving any try-finally statements.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdge.TryFinallyStatements">
            <summary>
            Gets the try-finally statements that this control flow edge is leaving.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.Normal">
            <summary>
            Regular control flow.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.ConditionTrue">
            <summary>
            Conditional control flow (edge taken if condition is true)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.ConditionFalse">
            <summary>
            Conditional control flow (edge taken if condition is false)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.Jump">
            <summary>
            A jump statement (goto, goto case, break or continue)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder">
            <summary>
            Constructs the control flow graph for C# statements.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.EvaluateOnlyPrimitiveConstants">
            <summary>
            Gets/Sets whether to handle only primitive expressions as constants (no complex expressions like "a + b").
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.EvaluateConstant(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The constant value of the expression; or null if the expression is not a constant.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.EvaluateCondition(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The value of the constant boolean expression; or null if the value is not a constant boolean expression.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.NodeCreationVisitor.CreateConnectedEndNode(ICSharpCode.NRefactory.CSharp.Statement,ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNode)">
            <summary>
            Creates an end node for <c>stmt</c> and connects <c>from</c> with the new node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.ExportGraph(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNode})">
            <summary>
            Debugging helper that exports a control flow graph.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus">
            <summary>
            Represents the definite assignment status of a variable at a specific location.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.PotentiallyAssigned">
            <summary>
            The variable might be assigned or unassigned.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.DefinitelyAssigned">
            <summary>
            The variable is definitely assigned.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.AssignedAfterTrueExpression">
            <summary>
            The variable is definitely assigned iff the expression results in the value 'true'.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.AssignedAfterFalseExpression">
            <summary>
            The variable is definitely assigned iff the expression results in the value 'false'.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.CodeUnreachable">
            <summary>
            The code is unreachable.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis">
            <summary>
            Implements the C# definite assignment analysis (C# 4.0 Spec: §5.3 Definite assignment)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.UnassignedVariableUses">
            <summary>
            Gets the unassigned usages of the previously analyzed variable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.SetAnalyzedRange(ICSharpCode.NRefactory.CSharp.Statement,ICSharpCode.NRefactory.CSharp.Statement,System.Boolean,System.Boolean)">
            <summary>
            Sets the range of statements to be analyzed.
            This method can be used to restrict the analysis to only a part of the method.
            Only the control flow paths that are fully contained within the selected part will be analyzed.
            </summary>
            <remarks>By default, both 'start' and 'end' are inclusive.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.ExportGraph">
            <summary>
            Exports the CFG. This method is intended to help debugging issues related to definite assignment.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.EvaluateConstant(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The constant value of the expression; or null if the expression is not a constant.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.EvaluateCondition(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The value of the constant boolean expression; or null if the value is not a constant boolean expression.</returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.ReachabilityAnalysis">
            <summary>
            Statement reachability analysis.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetRegion">
            <summary>
            Gets the region from StartLocation to EndLocation for this node.
            The file name of the region is set based on the parent SyntaxTree's file name.
            If this node is not connected to a whole compilation, the file name will be null.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.Ancestors">
            <summary>
            Gets the ancestors of this node (excluding this node itself)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.AncestorsAndSelf">
            <summary>
            Gets the ancestors of this node (including this node itself)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.Descendants">
            <summary>
            Gets all descendants of this node (excluding this node itself) in pre-order.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.DescendantsAndSelf">
            <summary>
            Gets all descendants of this node (including this node itself) in pre-order.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetChildByRole``1(ICSharpCode.NRefactory.Role{``0})">
            <summary>
            Gets the first child with the specified role.
            Returns the role's null object if the child is not found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.AddChildUnsafe(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Role)">
            <summary>
            Adds a child without performing any safety checks.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Remove">
            <summary>
            Removes this node from its parent.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.ReplaceWith(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Replaces this node with the new node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Clone">
            <summary>
            Clones the whole subtree starting at this AST node.
            </summary>
            <remarks>Annotations are copied over to the new nodes; and any annotations implementing ICloneable will be cloned.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNextNode(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">
            <summary>
            Gets the next node which fullfills a given predicate
            </summary>
            <returns>The next node.</returns>
            <param name="pred">The predicate.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetPrevNode(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">
            <summary>
            Gets the previous node which fullfills a given predicate
            </summary>
            <returns>The next node.</returns>
            <param name="pred">The predicate.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNextSibling(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">
            <summary>
            Gets the next sibling which fullfills a given predicate
            </summary>
            <returns>The next node.</returns>
            <param name="pred">The predicate.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetPrevSibling(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">
            <summary>
            Gets the next sibling which fullfills a given predicate
            </summary>
            <returns>The next node.</returns>
            <param name="pred">The predicate.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt(System.Int32,System.Int32,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt(ICSharpCode.NRefactory.TextLocation,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by pred at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt``1(System.Int32,System.Int32)">
            <summary>
            Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt``1(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Gets the node specified by T at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt(System.Int32,System.Int32,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by pred at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt(ICSharpCode.NRefactory.TextLocation,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by pred at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt``1(System.Int32,System.Int32)">
            <summary>
            Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt``1(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Gets the node specified by T at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeContaining(ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Gets the node that fully contains the range from startLocation to endLocation.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodesBetween(System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>
            Returns the root nodes of all subtrees that are fully contained in the specified region.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodesBetween(ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Returns the root nodes of all subtrees that are fully contained between <paramref name="start"/> and <paramref name="end"/> (inclusive).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.ToString(ICSharpCode.NRefactory.CSharp.CSharpFormattingOptions)">
            <summary>
            Gets the node as formatted C# output.
            </summary>
            <param name='formattingOptions'>
            Formatting options.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Contains(System.Int32,System.Int32)">
            <summary>
            Returns true, if the given coordinates (line, column) are in the node.
            </summary>
            <returns>
            True, if the given coordinates are between StartLocation and EndLocation (exclusive); otherwise, false.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Contains(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Returns true, if the given coordinates are in the node.
            </summary>
            <returns>
            True, if location is between StartLocation and EndLocation (exclusive); otherwise, false.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.IsInside(System.Int32,System.Int32)">
            <summary>
            Returns true, if the given coordinates (line, column) are in the node.
            </summary>
            <returns>
            True, if the given coordinates are between StartLocation and EndLocation (inclusive); otherwise, false.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.IsInside(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Returns true, if the given coordinates are in the node.
            </summary>
            <returns>
            True, if location is between StartLocation and EndLocation (inclusive); otherwise, false.
            </returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1">
            <summary>
            Represents the children of an AstNode that have a specific role.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1.FirstOrNullObject(System.Func{`0,System.Boolean})">
            <summary>
            Returns the first element for which the predicate returns true,
            or the null node (AstNode with IsNull=true) if no such object is found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1.LastOrNullObject(System.Func{`0,System.Boolean})">
            <summary>
            Returns the last element for which the predicate returns true,
            or the null node (AstNode with IsNull=true) if no such object is found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1.AcceptVisitor(ICSharpCode.NRefactory.CSharp.IAstVisitor)">
            <summary>
            Applies the <paramref name="visitor"/> to all nodes in this collection.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AstType">
            <summary>
            A type reference in the C# AST.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.IsVar">
            <summary>
            Gets whether this type is a SimpleType "var".
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.ToTypeReference(ICSharpCode.NRefactory.TypeSystem.InterningProvider)">
            <summary>
            Create an ITypeReference for this AstType.
            Uses the context (ancestors of this node) to determine the correct <see cref="T:ICSharpCode.NRefactory.CSharp.NameLookupMode"/>.
            </summary>
            <remarks>
            The resulting type reference will read the context information from the
            <see cref="T:ICSharpCode.NRefactory.TypeSystem.ITypeResolveContext"/>:
            For resolving type parameters, the CurrentTypeDefinition/CurrentMember is used.
            For resolving simple names, the current namespace and usings from the CurrentUsingScope
            (on CSharpTypeResolveContext only) is used.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.ToTypeReference(ICSharpCode.NRefactory.CSharp.NameLookupMode,ICSharpCode.NRefactory.TypeSystem.InterningProvider)">
            <summary>
            Create an ITypeReference for this AstType.
            </summary>
            <remarks>
            The resulting type reference will read the context information from the
            <see cref="T:ICSharpCode.NRefactory.TypeSystem.ITypeResolveContext"/>:
            For resolving type parameters, the CurrentTypeDefinition/CurrentMember is used.
            For resolving simple names, the current namespace and usings from the CurrentUsingScope
            (on CSharpTypeResolveContext only) is used.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.GetNameLookupMode">
            <summary>
            Gets the name lookup mode from the context (looking at the ancestors of this <see cref="T:ICSharpCode.NRefactory.CSharp.AstType"/>).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MakePointerType">
            <summary>
            Creates a pointer type from this type by nesting it in a <see cref="T:ICSharpCode.NRefactory.CSharp.ComposedType"/>.
            If this type already is a pointer type, this method just increases the PointerRank of the existing pointer type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MakeArrayType(System.Int32)">
            <summary>
            Creates an array type from this type by nesting it in a <see cref="T:ICSharpCode.NRefactory.CSharp.ComposedType"/>.
            If this type already is an array type, the additional rank is prepended to the existing array specifier list.
            Thus, <c>new SimpleType("T").MakeArrayType(1).MakeArrayType(2)</c> will result in "T[,][]".
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MakeNullableType">
            <summary>
            Creates a nullable type from this type by nesting it in a <see cref="T:ICSharpCode.NRefactory.CSharp.ComposedType"/>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Member(System.String,System.Object)">
            <summary>
            Builds an expression that can be used to access a static member on this type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MemberType(System.String,ICSharpCode.NRefactory.CSharp.AstType[])">
            <summary>
            Builds an expression that can be used to access a static member on this type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MemberType(System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstType})">
            <summary>
            Builds an expression that can be used to access a static member on this type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke(System.Object,System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke(System.String,ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke2(System.Object,System.String,ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke(System.Object,System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstType},System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Create(System.String,System.Object)">
            <summary>
            Creates a simple AstType from a dotted name.
            Does not support generics, arrays, etc. - just simple dotted names,
            e.g. namespace names.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DocumentationReference">
            <summary>
            Represents a 'cref' reference in XML documentation.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.SymbolKind">
            <summary>
            Gets/Sets the entity type.
            Possible values are:
              <c>SymbolKind.Operator</c> for operators,
              <c>SymbolKind.Indexer</c> for indexers,
              <c>SymbolKind.TypeDefinition</c> for references to primitive types,
              and <c>SymbolKind.None</c> for everything else.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.OperatorType">
            <summary>
            Gets/Sets the operator type.
            This property is only used when SymbolKind==Operator.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.HasParameterList">
            <summary>
            Gets/Sets whether a parameter list was provided.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.DeclaringType">
            <summary>
            Gets/Sets the declaring type.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.MemberName">
            <summary>
            Gets/sets the member name.
            This property is only used when SymbolKind==None.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.ConversionOperatorReturnType">
            <summary>
            Gets/Sets the return type of conversion operators.
            This property is only used when SymbolKind==Operator and OperatorType is explicit or implicit.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IdentifierExpressionBackreference">
            <summary>
            Matches identifier expressions that have the same identifier as the referenced variable/type definition/method definition.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.SyntaxExtensions">
            <summary>
            Extension methods for the syntax tree.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.FileName">
            <summary>
            Gets/Sets the file name of this syntax tree.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.ConditionalSymbols">
            <summary>
            Gets the conditional symbols used to parse the source file. Note that this list contains
            the conditional symbols at the start of the first token in the file - including the ones defined
            in the source file.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.TopExpression">
            <summary>
            Gets the expression that was on top of the parse stack.
            This is the only way to get an expression that isn't part of a statment.
            (eg. when an error follows an expression).
            
            This is used for code completion to 'get the expression before a token - like ., &lt;, ('.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.GetTypes(System.Boolean)">
            <summary>
            Gets all defined types in this syntax tree.
            </summary>
            <returns>
            A list containing <see cref="T:ICSharpCode.NRefactory.CSharp.TypeDeclaration"/> or <see cref="T:ICSharpCode.NRefactory.CSharp.DelegateDeclaration"/> nodes.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem">
            <summary>
            Converts this syntax tree into a parsed file that can be stored in the type system.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArraySpecifier">
            <summary>
            [,,,]
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CSharpTokenNode">
            <summary>
            Represents a token in C#. Note that the type of the token is defined through the TokenRole.
            </summary>
            <remarks>
            In all non null c# token nodes the Role of a CSharpToken must be a TokenRole.
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DepthFirstAstVisitor">
            <summary>
            AST visitor with a default implementation that visits all node depth-first.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DepthFirstAstVisitor`1">
            <summary>
            AST visitor with a default implementation that visits all node depth-first.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DepthFirstAstVisitor`2">
            <summary>
            AST visitor with a default implementation that visits all node depth-first.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ErrorNode">
            <summary>
            Represents a parsing error in the ast. At the moment it only represents missing closing bracket.
            This closing bracket is replaced by a node at the highest possible position.
            (To make GetAstNodeAt (line, col) working).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AnonymousMethodExpression">
            <summary>
            [async] delegate(Parameters) {Body}
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AnonymousTypeCreateExpression">
            <summary>
            new { [ExpressionList] }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArrayCreateExpression">
            <summary>
            new Type[Dimensions]
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.ArrayCreateExpression.AdditionalArraySpecifiers">
            <summary>
            Gets additional array ranks (those without size info).
            Empty for "new int[5,1]"; will contain a single element for "new int[5][]".
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArrayInitializerExpression">
            <summary>
            { Elements }
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.ArrayInitializerExpression.IsSingleElement">
            <summary>
            For ease of use purposes in the resolver the ast representation
            of { a, b, c }  is { {a}, {b}, {c} }.
            If IsSingleElement is true then this array initializer expression is a generated one.
            That has no meaning in the source code (and contains no brace tokens).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArrayInitializerExpression.SingleArrayInitializerExpression">
            <summary>
            Single elements in array initializers are represented with this special class.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AsExpression">
            <summary>
            Expression as TypeReference
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AssignmentExpression">
            <summary>
            Left Operator= Right
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AssignmentExpression.GetCorrespondingBinaryOperator(ICSharpCode.NRefactory.CSharp.AssignmentOperatorType)">
            <summary>
            Gets the binary operator for the specified compound assignment operator.
            Returns null if 'op' is not a compound assignment.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Assign">
            <summary>left = right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Add">
            <summary>left += right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Subtract">
            <summary>left -= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Multiply">
            <summary>left *= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Divide">
            <summary>left /= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Modulus">
            <summary>left %= right</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ShiftLeft" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ShiftRight">
            <summary>left >>= right</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.BitwiseAnd" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.BitwiseOr">
            <summary>left |= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ExclusiveOr">
            <summary>left ^= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Any">
            <summary>Any operator (for pattern matching)</summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BaseReferenceExpression">
            <summary>
            base
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BinaryOperatorExpression">
            <summary>
            Left Operator Right
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Any">
            <summary>
            Any binary operator (used in pattern matching)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseAnd">
            <summary>left &amp; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseOr">
            <summary>left | right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ConditionalAnd">
            <summary>left &amp;&amp; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ConditionalOr">
            <summary>left || right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ExclusiveOr">
            <summary>left ^ right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThan">
            <summary>left &gt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThanOrEqual">
            <summary>left &gt;= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Equality">
            <summary>left == right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.InEquality">
            <summary>left != right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThan">
            <summary>left &lt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThanOrEqual">
            <summary>left &lt;= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Add">
            <summary>left + right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Subtract">
            <summary>left - right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Multiply">
            <summary>left * right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Divide">
            <summary>left / right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Modulus">
            <summary>left % right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftLeft">
            <summary>left &lt;&lt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftRight">
            <summary>left &gt;&gt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.NullCoalescing">
            <summary>left ?? right</summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CastExpression">
            <summary>
            (CastTo)Expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CheckedExpression">
            <summary>
            checked(Expression)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ConditionalExpression">
            <summary>
            Condition ? TrueExpression : FalseExpression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DefaultValueExpression">
            <summary>
            default(Type)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DirectionExpression">
            <summary>
            ref Expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Expression">
            <summary>
            Base class for expressions.
            </summary>
            <remarks>
            This class is useful even though it doesn't provide any additional functionality:
            It can be used to communicate more information in APIs, e.g. "this subnode will always be an expression"
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Member(System.String,System.Object)">
            <summary>
            Builds an member reference expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Indexer(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an indexer expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Indexer(ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an indexer expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.Object,System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.String,ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke2(System.Object,System.String,ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.Object,System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstType},System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IndexerExpression">
            <summary>
            Target[Arguments]
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.InvocationExpression">
            <summary>
            Target(Arguments)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IsExpression">
            <summary>
            Expression is Type
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.LambdaExpression">
            <summary>
            [async] Parameters => Body
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.MemberReferenceExpression">
            <summary>
            Target.MemberName
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NamedArgumentExpression">
            <summary>
            Represents a named argument passed to a method or attribute.
            name: expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NamedExpression">
            <summary>
            name = expression
            This isn't the same as 'assign' even though it has the same syntax.
            This expression is used in object initializers and for named attribute arguments [Attr(FieldName = value)].
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NullReferenceExpression">
            <summary>
            null
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ObjectCreateExpression">
            <summary>
            new Type(Arguments) { Initializer }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ParenthesizedExpression">
            <summary>
            ( Expression )
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.ParenthesizedExpression.ActsAsParenthesizedExpression(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets whether the expression acts like a parenthesized expression,
            i.e. whether information about the expected type (for lambda type inference) flows
            into the inner expression.
            </summary>
            <returns>Returns true for ParenthesizedExpression, CheckedExpression or UncheckedExpression; false otherwise.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.ParenthesizedExpression.UnpackParenthesizedExpression(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Unpacks the given expression if it is a ParenthesizedExpression, CheckedExpression or UncheckedExpression.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.PointerReferenceExpression">
            <summary>
            Target->MemberName
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.PrimitiveExpression">
            <summary>
            Represents a literal value.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.PrimitiveExpression.LiteralValue">
            <remarks>Never returns null.</remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.PrimitiveExpression.UnsafeLiteralValue">
            <remarks>Can be null.</remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.QueryContinuationClause">
            <summary>
            Represents a query continuation.
            "(from .. select ..) into Identifier" or "(from .. group .. by ..) into Identifier"
            Note that "join .. into .." is not a query continuation!
            
            This is always the first(!!) clause in a query expression.
            The tree for "from a in b select c into d select e" looks like this:
            new QueryExpression {
            	new QueryContinuationClause {
            		PrecedingQuery = new QueryExpression {
            			new QueryFromClause(a in b),
            			new QuerySelectClause(c)
            		},
            		Identifier = d
            	},
            	new QuerySelectClause(e)
            }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.QueryJoinClause">
            <summary>
            Represents a join or group join clause.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.SizeOfExpression">
            <summary>
            sizeof(Type)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.StackAllocExpression">
            <summary>
            stackalloc Type[Count]
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ThisReferenceExpression">
            <summary>
            this
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeOfExpression">
            <summary>
            typeof(Type)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeReferenceExpression">
            <summary>
            Represents an AstType as an expression.
            This is used when calling a method on a primitive type: "int.Parse()"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UnaryOperatorExpression">
            <summary>
            Operator Expression
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Any">
            <summary>
            Any unary operator (used in pattern matching)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Not">
            <summary>Logical not (!a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.BitNot">
            <summary>Bitwise not (~a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Minus">
            <summary>Unary minus (-a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Plus">
            <summary>Unary plus (+a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Increment">
            <summary>Pre increment (++a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Decrement">
            <summary>Pre decrement (--a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.PostIncrement">
            <summary>Post increment (a++)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.PostDecrement">
            <summary>Post decrement (a--)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Dereference">
            <summary>Dereferencing (*a)</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.AddressOf" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Await">
            <summary>C# 5.0 await</summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UncheckedExpression">
            <summary>
            unchecked(Expression)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UndocumentedExpression">
            <summary>
            Represents undocumented expressions.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Attribute">
            <summary>
            Attribute(Arguments)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AttributeSection">
            <summary>
            [AttributeTarget: Attributes]
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.SingleLine">
            <summary>
            "//" comment
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.MultiLine">
            <summary>
            "/* */" comment
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.Documentation">
            <summary>
            "///" comment
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.InactiveCode">
            <summary>
            Inactive code (code in non-taken "#if")
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.MultiLineDocumentation">
            <summary>
            "/** */" comment
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Comment.IsDocumentation">
            <summary>
            Returns true if the <see cref="P:ICSharpCode.NRefactory.CSharp.Comment.CommentType"/> is Documentation or MultiLineDocumentation.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Constraint">
            <summary>
            where TypeParameter : BaseTypes
            </summary>
            <remarks>
            new(), struct and class constraints are represented using a PrimitiveType "new", "struct" or "class"
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DelegateDeclaration">
            <summary>
            delegate ReturnType Name&lt;TypeParameters&gt;(Parameters) where Constraints;
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.ExternAliasDeclaration" -->
        <member name="T:ICSharpCode.NRefactory.CSharp.NamespaceDeclaration">
            <summary>
            namespace Name { Members }
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.NamespaceDeclaration.FullName">
            <summary>
            Gets the full namespace name (including any parent namespaces)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeDeclaration">
            <summary>
            class Name&lt;TypeParameters&gt; : BaseTypes where Constraints;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeParameterDeclaration">
            <summary>
            [in|out] Name
            
            Represents a type parameter.
            Note: mirroring the C# syntax, constraints are not part of the type parameter declaration, but belong
            to the parent type or method.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UsingAliasDeclaration">
            <summary>
            using Alias = Import;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UsingDeclaration">
            <summary>
            using Import;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IAstVisitor">
            <summary>
            AST visitor.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IAstVisitor`1">
            <summary>
            AST visitor.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IAstVisitor`2">
            <summary>
            AST visitor.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Modifiers.Any">
            <summary>
            Special value used to match any modifiers during pattern matching.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.TypeReference">
            <summary>
            AstType
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.TypeDeclaration">
            <summary>
            Type or delegate declaration
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.Whitespace">
            <summary>
            Comment or whitespace or pre-processor directive 
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.Pattern">
            <summary>
            Placeholder for a pattern
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BlockStatement">
            <summary>
            { Statements }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BreakStatement">
            <summary>
            break;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CheckedStatement">
            <summary>
            checked BodyBlock
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ContinueStatement">
            <summary>
            continue;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DoWhileStatement">
            <summary>
            "do EmbeddedStatement while(Condition);"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.EmptyStatement">
            <summary>
            ;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ExpressionStatement">
            <summary>
            Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.FixedStatement">
            <summary>
            fixed (Type Variables) EmbeddedStatement
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ForeachStatement">
            <summary>
            foreach (Type VariableName in InExpression) EmbeddedStatement
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ForStatement">
            <summary>
            for (Initializers; Condition; Iterators) EmbeddedStatement
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.ForStatement.Initializers">
            <summary>
            Gets the list of initializer statements.
            Note: this contains multiple statements for "for (a = 2, b = 1; a > b; a--)", but contains
            only a single statement for "for (int a = 2, b = 1; a > b; a--)" (a single VariableDeclarationStatement with two variables)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GotoStatement">
            <summary>
            "goto Label;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GotoCaseStatement">
            <summary>
            or "goto case LabelExpression;"
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.GotoCaseStatement.LabelExpression">
            <summary>
            Used for "goto case LabelExpression;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GotoDefaultStatement">
            <summary>
            or "goto default;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IfElseStatement">
            <summary>
            if (Condition) TrueStatement else FalseStatement
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.LabelStatement">
            <summary>
            Label:
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.LockStatement">
            <summary>
            lock (Expression) EmbeddedStatement;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ReturnStatement">
            <summary>
            return Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Statement">
            <summary>
            Base class for statements.
            </summary>
            <remarks>
            This class is useful even though it doesn't provide any additional functionality:
            It can be used to communicate more information in APIs, e.g. "this subnode will always be a statement"
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.SwitchStatement">
            <summary>
            switch (Expression) { SwitchSections }
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CaseLabel.Expression">
            <summary>
            Gets or sets the expression. The expression can be null - if the expression is null, it's the default switch section.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ThrowStatement">
            <summary>
            throw Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TryCatchStatement">
            <summary>
            try TryBlock CatchClauses finally FinallyBlock
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CatchClause">
            <summary>
            catch (Type VariableName) { Body }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UncheckedStatement">
            <summary>
            unchecked BodyBlock
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UnsafeStatement">
            <summary>
            unsafe { Body }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UsingStatement">
            <summary>
            using (ResourceAcquisition) EmbeddedStatement
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.UsingStatement.ResourceAcquisition">
            <summary>
            Either a VariableDeclarationStatement, or an Expression.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.WhileStatement">
            <summary>
            "while (Condition) EmbeddedStatement"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.YieldBreakStatement">
            <summary>
            yield break;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.YieldReturnStatement">
            <summary>
            yield return Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Accessor">
            <summary>
            get/set/add/remove
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Accessor.Keyword">
            <summary>
            Gets the 'get'/'set'/'add'/'remove' keyword
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CustomEventDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.FixedVariableInitializer">
            <summary>
            Name [ CountExpression ]
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.IndexerDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.MethodDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.OperatorDeclaration.GetOperatorType(System.String)">
            <summary>
            Gets the operator type from the method name, or null, if the method does not represent one of the known operator types.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.OperatorDeclaration.GetName(ICSharpCode.NRefactory.CSharp.OperatorType)">
            <summary>
            Gets the method name for the operator type. ("op_Addition", "op_Implicit", etc.)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.OperatorDeclaration.GetToken(ICSharpCode.NRefactory.CSharp.OperatorType)">
            <summary>
            Gets the token for the operator type ("+", "implicit", etc.)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.PropertyDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor">
            <summary>
            Inserts the parentheses into the AST that are needed to ensure the AST can be printed correctly.
            For example, if the AST contains
            BinaryOperatorExpresson(2, Mul, BinaryOperatorExpression(1, Add, 1))); printing that AST
            would incorrectly result in "2 * 1 + 1". By running InsertParenthesesVisitor, the necessary
            parentheses are inserted: "2 * (1 + 1)".
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor.InsertParenthesesForReadability">
            <summary>
            Gets/Sets whether the visitor should insert parentheses to make the code better looking.
            If this property is false, it will insert parentheses only where strictly required by the language spec.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor.GetPrecedence(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Gets the row number in the C# 4.0 spec operator precedence table.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor.ParenthesizeIfRequired(ICSharpCode.NRefactory.CSharp.Expression,System.Int32)">
            <summary>
            Parenthesizes the expression if it does not have the minimum required precedence.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.InsertRequiredSpacesDecorator.lastWritten">
            <summary>
            Used to insert the minimal amount of spaces so that the lexer recognizes the tokens that were written.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor">
            <summary>
            Outputs the AST.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Comma(ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean)">
            <summary>
            Writes a comma.
            </summary>
            <param name="nextNode">The next node after the comma.</param>
            <param name="noSpaceAfterComma">When set prevents printing a space after comma.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.OptionalComma(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes an optional comma, e.g. at the end of an enum declaration or in an array initializer
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.OptionalSemicolon(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes an optional semicolon, e.g. at the end of a type or namespace declaration.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.WriteKeyword(ICSharpCode.NRefactory.CSharp.TokenRole,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes a keyword, and all specials up to
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Semicolon(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Marks the end of a statement
            </summary>
            <param name="node">Statement node or null</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Space(System.Boolean)">
            <summary>
            Writes a space depending on policy.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.IsKeyword(System.String,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Determines whether the specified identifier is a keyword in the given context.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.ConvertString(System.String)">
            <summary>
            Converts special characters to escape sequences within the given string.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertSpecialsDecorator.WriteSpecials(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes all specials from start to end (exclusive). Does not touch the positionStack.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertSpecialsDecorator.WriteSpecialsUpToRole(ICSharpCode.NRefactory.Role)">
            <summary>
            Writes all specials between the current position (in the positionStack) and the next
            node with the specified role. Advances the current position.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertSpecialsDecorator.WriteSpecialsUpToNode(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes all specials between the current position (in the positionStack) and the specified node.
            Advances the current position.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TokenWriter.WriteIdentifier(ICSharpCode.NRefactory.CSharp.Identifier,System.Object)">
            <summary>
            Writes an identifier.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TokenWriter.WriteKeyword(ICSharpCode.NRefactory.Role,System.String)">
            <summary>
            Writes a keyword to the output.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TokenWriter.WriteToken(ICSharpCode.NRefactory.Role,System.String,System.Object)">
            <summary>
            Writes a token to the output.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TokenWriter.WritePrimitiveValue(System.Object,System.Object,System.String)">
            <summary>
            Writes a primitive/literal value
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TextWriterTokenWriter">
            <summary>
            Writes C# code into a TextWriter.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TextWriterTokenWriter.ConvertCharLiteral(System.Char)">
            <summary>
            Gets the escape sequence for the specified character within a char literal.
            Does not include the single quotes surrounding the char literal.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TextWriterTokenWriter.ConvertChar(System.Char)">
            <summary>
            Gets the escape sequence for the specified character.
            </summary>
            <remarks>This method does not convert ' or ".</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TextWriterTokenWriter.ConvertString(System.String)">
            <summary>
            Converts special characters to escape sequences within the given string.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult">
            <summary>
            Represents the result of an await expression.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.GetAwaiterInvocation">
            <summary>
            The method representing the GetAwaiter() call. Can be an <see cref="T:ICSharpCode.NRefactory.Semantics.InvocationResolveResult"/> or a <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult"/>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.AwaiterType">
            <summary>
            Awaiter type. Will not be null (but can be UnknownType).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.IsCompletedProperty">
            <summary>
            Property representing the IsCompleted property on the awaiter type. Can be null if the awaiter type or the property was not found, or when awaiting a dynamic expression.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.OnCompletedMethod">
            <summary>
            Method representing the OnCompleted method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.
            This can also refer to an UnsafeOnCompleted method, if the awaiter type implements <c>System.Runtime.CompilerServices.ICriticalNotifyCompletion</c>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.GetResultMethod">
            <summary>
            Method representing the GetResult method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.Invocation">
            <summary>
            The invocation is a normal invocation ( 'a(b)' ).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.Indexing">
            <summary>
            The invocation is an indexing ( 'a[b]' ).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.ObjectCreation">
            <summary>
            The invocation is an object creation ( 'new a(b)' ). Also used when invoking a base constructor ( ' : base(a) ' ) and chaining constructors ( ' : this(a) ').
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult">
            <summary>
            Represents the result of an invocation of a member of a dynamic object.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.Target">
            <summary>
            Target of the invocation. Can be a dynamic expression or a <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult"/>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.InvocationType">
            <summary>
            Type of the invocation.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.Arguments">
            <summary>
            Arguments for the call. Named arguments will be instances of <see cref="T:ICSharpCode.NRefactory.Semantics.NamedArgumentResolveResult"/>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.InitializerStatements">
            <summary>
            Gets the list of initializer statements that are appplied to the result of this invocation.
            This is used to represent object and collection initializers.
            With the initializer statements, the <see cref="T:ICSharpCode.NRefactory.Semantics.InitializedObjectResolveResult"/> is used
            to refer to the result of this invocation.
            Initializer statements can only exist if the <see cref="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.InvocationType"/> is <see cref="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.ObjectCreation"/>.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult">
            <summary>
            Represents the result of an access to a member of a dynamic object.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult.Target">
            <summary>
            Target of the member access (a dynamic object).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult.Member">
            <summary>
            Name of the accessed member.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions">
            <summary>
            Contains logic that determines whether an implicit conversion exists between two types.
            </summary>
            <remarks>
            This class is thread-safe.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.Get(ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Gets the Conversions instance for the specified <see cref="T:ICSharpCode.NRefactory.TypeSystem.ICompilation"/>.
            This will make use of the context's cache manager to reuse the Conversions instance.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsConstraintConvertible(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether the type 'fromType' is convertible to 'toType'
            using one of the conversions allowed when satisying constraints (§4.4.4)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IdentityConversion(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether there is an identity conversion from <paramref name="fromType"/> to <paramref name="toType"/>
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.UnpackGenericArrayInterface(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            For IList{T}, ICollection{T}, IEnumerable{T} and IReadOnlyList{T}, returns T.
            Otherwise, returns null.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.ImplicitTypeParameterConversion(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Implicit conversions involving type parameters.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsEncompassedBy(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether type A is encompassed by type B.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsDelegateCompatible(ICSharpCode.NRefactory.TypeSystem.IMethod,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether a <paramref name="method"/> is compatible with a delegate type.
            §15.2 Delegate compatibility
            </summary>
            <param name="method">The method to test for compatibility</param>
            <param name="delegateType">The delegate type</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsDelegateCompatible(ICSharpCode.NRefactory.TypeSystem.IMethod,ICSharpCode.NRefactory.TypeSystem.IMethod,System.Boolean)">
            <summary>
            Gets whether a method <paramref name="m"/> is compatible with a delegate type.
            §15.2 Delegate compatibility
            </summary>
            <param name="m">The method to test for compatibility</param>
            <param name="invoke">The invoke method of the delegate</param>
            <param name="isExtensionMethodInvocation">Gets whether m is accessed using extension method syntax.
            If this parameter is true, the first parameter of <paramref name="m"/> will be ignored.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.BetterConversion(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the better conversion (C# 4.0 spec, §7.5.3.3)
            </summary>
            <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.UnpackTask(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Unpacks the generic Task[T]. Returns null if the input is not Task[T].
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.BetterConversion(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the better conversion (C# 4.0 spec, §7.5.3.4)
            </summary>
            <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.BetterConversionTarget(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the better conversion target (C# 4.0 spec, §7.5.3.5)
            </summary>
            <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver">
            <summary>
            Resolves C# AST nodes.
            </summary>
            <remarks>This class is thread-safe.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.#ctor(ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Creates a new C# AST resolver.
            Use this overload if you are resolving within a complete C# file.
            </summary>
            <param name="compilation">The current compilation.</param>
            <param name="syntaxTree">The syntax tree to be resolved.</param>
            <param name="unresolvedFile">
            Optional: Result of <see cref="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem"/> for the file being resolved.
            <para>
            This is used for setting up the context on the resolver. The unresolved file must be registered in the compilation.
            </para>
            <para>
            When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
            member declarations in the AST with members in the type system.
            When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
            member's signature in the AST with the signature in the type system.
            </para>
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Creates a new C# AST resolver.
            Use this overload if you are resolving code snippets (not necessarily complete files).
            </summary>
            <param name="resolver">The resolver state at the root node (to be more precise: just outside the root node).</param>
            <param name="rootNode">The root node of the tree to be resolved.</param>
            <param name="unresolvedFile">
            Optional: Result of <see cref="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem"/> for the file being resolved.
            <para>
            This is used for setting up the context on the resolver. The unresolved file must be registered in the compilation.
            </para>
            <para>
            When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
            member declarations in the AST with members in the type system.
            When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
            member's signature in the AST with the signature in the type system.
            </para>
            </param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.TypeResolveContext">
            <summary>
            Gets the type resolve context for the root resolver.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.Compilation">
            <summary>
            Gets the compilation for this resolver.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.RootNode">
            <summary>
            Gets the root node for which this CSharpAstResolver was created.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.UnresolvedFile">
            <summary>
            Gets the unresolved file used by this CSharpAstResolver.
            Can return null.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.ApplyNavigator(ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator,System.Threading.CancellationToken)">
            <summary>
            Applies a resolver navigator. This will resolve the nodes requested by the navigator, and will inform the
            navigator of the results.
            This method must be called as the first operation on the CSharpAstResolver, it is invalid to apply a navigator
            after a portion of the file was already resolved.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.Resolve(ICSharpCode.NRefactory.CSharp.AstNode,System.Threading.CancellationToken)">
            <summary>
            Resolves the specified node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetResolverStateBefore(ICSharpCode.NRefactory.CSharp.AstNode,System.Threading.CancellationToken)">
            <summary>
            Gets the resolver state immediately before the specified node.
            That is, if the node is a variable declaration, the returned state will not contain the newly declared variable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetResolverStateAfter(ICSharpCode.NRefactory.CSharp.AstNode,System.Threading.CancellationToken)">
            <summary>
            Gets the resolver state immediately after the specified node.
            That is, if the node is a variable declaration, the returned state will include the newly declared variable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetExpectedType(ICSharpCode.NRefactory.CSharp.Expression,System.Threading.CancellationToken)">
            <summary>
            Gets the expected type for the specified node. This is the type that a node is being converted to.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetConversion(ICSharpCode.NRefactory.CSharp.Expression,System.Threading.CancellationToken)">
            <summary>
            Gets the conversion that is being applied to the specified expression.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.IsUnresolvableNode(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets whether the specified node is unresolvable.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult">
            <summary>
            Represents the result of a method, constructor or indexer invocation.
            Provides additional C#-specific information for InvocationResolveResult.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.IsExtensionMethodInvocation">
            <summary>
            Gets whether this invocation is calling an extension method using extension method syntax.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.IsDelegateInvocation">
            <summary>
            Gets whether this invocation is calling a delegate (without explicitly calling ".Invoke()").
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.IsExpandedForm">
            <summary>
            Gets whether a params-Array is being used in its expanded form.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.reducedMethod">
            <summary>
            If IsExtensionMethodInvocation is true this property holds the reduced method.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.GetArgumentToParameterMap">
            <summary>
            Gets an array that maps argument indices to parameter indices.
            For arguments that could not be mapped to any parameter, the value will be -1.
            
            parameterIndex = ArgumentToParameterMap[argumentIndex]
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpOperators.Get(ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Gets the CSharpOperators instance for the specified <see cref="T:ICSharpCode.NRefactory.TypeSystem.ICompilation"/>.
            This will make use of the context's cache manager (if available) to reuse the CSharpOperators instance.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver">
            <summary>
            Contains the main resolver logic.
            </summary>
            <remarks>
            This class is thread-safe.
            </remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.Compilation">
            <summary>
            Gets the compilation used by the resolver.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentTypeResolveContext">
            <summary>
            Gets the current type resolve context.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CheckForOverflow">
            <summary>
            Gets whether the current context is <c>checked</c>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCheckForOverflow(System.Boolean)">
            <summary>
            Sets whether the current context is <c>checked</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsWithinLambdaExpression">
            <summary>
            Gets whether the resolver is currently within a lambda expression or anonymous method.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithIsWithinLambdaExpression(System.Boolean)">
            <summary>
            Sets whether the resolver is currently within a lambda expression.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentMember">
            <summary>
            Gets the current member definition that is used to look up identifiers as parameters
            or type parameters.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCurrentMember(ICSharpCode.NRefactory.TypeSystem.IMember)">
            <summary>
            Sets the current member definition.
            </summary>
            <remarks>Don't forget to also set CurrentTypeDefinition when setting CurrentMember;
            setting one of the properties does not automatically set the other.</remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentUsingScope">
            <summary>
            Gets the current using scope that is used to look up identifiers as class names.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCurrentUsingScope(ICSharpCode.NRefactory.CSharp.TypeSystem.ResolvedUsingScope)">
            <summary>
            Sets the current using scope that is used to look up identifiers as class names.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentTypeDefinition">
            <summary>
            Gets the current type definition.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCurrentTypeDefinition(ICSharpCode.NRefactory.TypeSystem.ITypeDefinition)">
            <summary>
            Sets the current type definition.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PushBlock">
            <summary>
            Opens a new scope for local variables.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PopBlock">
            <summary>
            Closes the current scope for local variables; removing all variables in that scope.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.AddVariable(ICSharpCode.NRefactory.TypeSystem.IVariable)">
            <summary>
            Adds a new variable or lambda parameter to the current block.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PopLastVariable">
            <summary>
            Removes the variable that was just added.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.LocalVariables">
            <summary>
            Gets all currently visible local variables and lambda parameters.
            Does not include method parameters.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PushObjectInitializer(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Pushes the type of the object that is currently being initialized.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsInObjectInitializer">
            <summary>
            Gets whether this context is within an object initializer.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentObjectInitializer">
            <summary>
            Gets the current object initializer. This usually is an <see cref="T:ICSharpCode.NRefactory.Semantics.InitializedObjectResolveResult"/>
            or (for nested initializers) a semantic tree based on an <see cref="T:ICSharpCode.NRefactory.Semantics.InitializedObjectResolveResult"/>.
            Returns ErrorResolveResult if there is no object initializer.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentObjectInitializerType">
            <summary>
            Gets the type of the object currently being initialized.
            Returns SharedTypes.Unknown if no object initializer is currently open (or if the object initializer
            has unknown type).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.Clone">
            <summary>
            Creates a copy of this CSharp resolver.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.HandleEnumComparison(ICSharpCode.NRefactory.CSharp.BinaryOperatorType,ICSharpCode.NRefactory.TypeSystem.IType,System.Boolean,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Handle the case where an enum value is compared with another enum value
            bool operator op(E x, E y);
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.HandleEnumSubtraction(System.Boolean,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Handle the case where an enum value is subtracted from another enum value
            U operator –(E x, E y);
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.HandleEnumOperator(System.Boolean,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.BinaryOperatorType,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Handle the following enum operators:
            E operator +(E x, U y);
            E operator +(U x, E y);
            E operator –(E x, U y);
            E operator &amp;(E x, E y);
            E operator |(E x, E y);
            E operator ^(E x, E y);
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.TryConvertEnum(ICSharpCode.NRefactory.Semantics.ResolveResult@,ICSharpCode.NRefactory.TypeSystem.IType,System.Boolean@,ICSharpCode.NRefactory.Semantics.ResolveResult@,System.Boolean)">
            <summary>
            
            </summary>
            <param name="rr">The input resolve result that should be converted.
            If a conversion exists, it is applied to the resolve result</param>
            <param name="targetType">The target type that we should convert to</param>
            <param name="isNullable">Whether we are dealing with a lifted operator</param>
            <param name="enumRR">The resolve result that is enum-typed.
            If necessary, a nullable conversion is applied.</param>
            <param name="allowConversionFromConstantZero">
            Whether the conversion from the constant zero is allowed.
            </param>
            <returns>True if the conversion is successful; false otherwise.
            If the conversion is not successful, the ref parameters will not be modified.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveAlias(System.String)">
            <summary>
            Looks up an alias (identifier in front of :: operator)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CreateMemberLookup">
            <summary>
            Creates a MemberLookup instance using this resolver's settings.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CreateMemberLookup(ICSharpCode.NRefactory.CSharp.NameLookupMode)">
            <summary>
            Creates a MemberLookup instance using this resolver's settings.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.GetExtensionMethods(System.String,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Gets all extension methods that are available in the current context.
            </summary>
            <param name="name">Name of the extension method. Pass null to retrieve all extension methods.</param>
            <param name="typeArguments">Explicitly provided type arguments.
            An empty list will return all matching extension method definitions;
            a non-empty list will return <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>s for all extension methods
            with the matching number of type parameters.</param>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.GetExtensionMethods(ICSharpCode.NRefactory.TypeSystem.IType,System.String,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean)">
            <summary>
            Gets the extension methods that are called 'name'
            and are applicable with a first argument type of 'targetType'.
            </summary>
            <param name="targetType">Type of the 'this' argument</param>
            <param name="name">Name of the extension method. Pass null to retrieve all extension methods.</param>
            <param name="typeArguments">Explicitly provided type arguments.
            An empty list will return all matching extension method definitions;
            a non-empty list will return <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>s for all extension methods
            with the matching number of type parameters.</param>
            <param name="substituteInferredTypes">
            Specifies whether to produce a <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>
            when type arguments could be inferred from <paramref name="targetType"/>. This parameter
            is only used for inferred types and has no effect if <paramref name="typeArguments"/> is non-empty.
            </param>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsEligibleExtensionMethod(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IMethod,System.Boolean,ICSharpCode.NRefactory.TypeSystem.IType[]@)">
            <summary>
            Checks whether the specified extension method is eligible on the target type.
            </summary>
            <param name="targetType">Target type that is passed as first argument to the extension method.</param>
            <param name="method">The extension method.</param>
            <param name="useTypeInference">Whether to perform type inference for the method.
            Use <c>false</c> if <paramref name="method"/> is already parameterized (e.g. when type arguments were given explicitly).
            Otherwise, use <c>true</c>.
            </param>
            <param name="outInferredTypes">If the method is generic and <paramref name="useTypeInference"/> is <c>true</c>,
            and at least some of the type arguments could be inferred, this parameter receives the inferred type arguments.
            Since only the type for the first parameter is considered, not all type arguments may be inferred.
            If an array is returned, any slot with an uninferred type argument will be set to the method's
            corresponding type parameter.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.GetAllExtensionMethods(ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup)">
            <summary>
            Gets all extension methods available in the current using scope.
            This list includes inaccessible methods.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveInvocation(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult[],System.String[])">
            <summary>
            Resolves an invocation.
            </summary>
            <param name="target">The target of the invocation. Usually a MethodGroupResolveResult.</param>
            <param name="arguments">
            Arguments passed to the method.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="argumentNames">
            The argument names. Pass the null string for positional arguments.
            </param>
            <returns>InvocationResolveResult or UnknownMethodResolveResult</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveIndexer(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult[],System.String[])">
            <summary>
            Resolves an indexer access.
            </summary>
            <param name="target">Target expression.</param>
            <param name="arguments">
            Arguments passed to the indexer.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="argumentNames">
            The argument names. Pass the null string for positional arguments.
            </param>
            <returns>ArrayAccessResolveResult, InvocationResolveResult, or ErrorResolveResult</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.AdjustArrayAccessArguments(ICSharpCode.NRefactory.Semantics.ResolveResult[])">
            <summary>
            Converts all arguments to int,uint,long or ulong.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveObjectCreation(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.Semantics.ResolveResult[],System.String[],System.Boolean,System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult})">
            <summary>
            Resolves an object creation.
            </summary>
            <param name="type">Type of the object to create.</param>
            <param name="arguments">
            Arguments passed to the constructor.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="argumentNames">
            The argument names. Pass the null string for positional arguments.
            </param>
            <param name="allowProtectedAccess">
            Whether to allow calling protected constructors.
            This should be false except when resolving constructor initializers.
            </param>
            <param name="initializerStatements">
            Statements for Objects/Collections initializer.
            <see cref="F:ICSharpCode.NRefactory.Semantics.InvocationResolveResult.InitializerStatements"/>
            </param>
            <returns>InvocationResolveResult or ErrorResolveResult</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveSizeOf(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Resolves 'sizeof(type)'.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveThisReference">
            <summary>
            Resolves 'this'.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveBaseReference">
            <summary>
            Resolves 'base'.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveCondition(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Converts the input to <c>bool</c> using the rules for boolean expressions.
            That is, <c>operator true</c> is used if a regular conversion to <c>bool</c> is not possible.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveConditionFalse(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Converts the negated input to <c>bool</c> using the rules for boolean expressions.
            Computes <c>!(bool)input</c> if the implicit cast to bool is valid; otherwise
            computes <c>input.operator false()</c>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveArrayCreation(ICSharpCode.NRefactory.TypeSystem.IType,System.Int32[],ICSharpCode.NRefactory.Semantics.ResolveResult[])">
            <summary>
            Resolves an array creation.
            </summary>
            <param name="elementType">
            The array element type.
            Pass null to resolve an implicitly-typed array creation.
            </param>
            <param name="sizeArguments">
            The size arguments.
            The length of this array will be used as the number of dimensions of the array type.
            Negative values will be treated as errors.
            </param>
            <param name="initializerElements">
            The initializer elements. May be null if no array initializer was specified.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveArrayCreation(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.Semantics.ResolveResult[],ICSharpCode.NRefactory.Semantics.ResolveResult[])">
            <summary>
            Resolves an array creation.
            </summary>
            <param name="elementType">
            The array element type.
            Pass null to resolve an implicitly-typed array creation.
            </param>
            <param name="sizeArguments">
            The size arguments.
            The length of this array will be used as the number of dimensions of the array type.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="initializerElements">
            The initializer elements. May be null if no array initializer was specified.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator">
            <summary>
            When an <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator"/> is searching for specific nodes
            (e.g. all IdentifierExpressions), it has to scan the whole syntax tree for those nodes.
            However, scanning in the ResolveVisitor is expensive (e.g. any lambda that is scanned must be resolved),
            so it makes sense to detect when a whole subtree is scan-only, and skip that tree instead.
            
            The DetectSkippableNodesNavigator performs this job by running the input IResolveVisitorNavigator
            over the whole AST, and detecting subtrees that are scan-only, and replaces them with Skip.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <inheritdoc/>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator.Resolved(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <inheritdoc/>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.Conversion,ICSharpCode.NRefactory.TypeSystem.IType)">
            <inheritdoc/>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CastResolveResult">
            <summary>
            Represents an explicitly applied conversion (CastExpression or AsExpression)
            (a result belonging to an AST node; not implicitly inserted 'between' nodes).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.FindReferencedEntities">
            <summary>
            Find all entities that are referenced in the scanned AST.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferencedEntities.#ctor(System.Action{ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IEntity})">
            <summary>
            Creates a new FindReferencedEntities instance that
            looks for entity definitions.
            The visitor will report type definitions and member definitions (not specialized members).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferencedEntities.#ctor(System.Action{ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IType},System.Action{ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IMember})">
            <summary>
            Creates a new FindReferencedEntities instance that
            looks for types and members.
            The visitor will report parameterized types and potentially specialized members.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences">
            <summary>
            'Find references' implementation.
            </summary>
            <remarks>
            This class is thread-safe.
            The intended multi-threaded usage is to call GetSearchScopes() once, and then
            call FindReferencesInFile() concurrently on multiple threads (parallel foreach over all interesting files).
            </remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindTypeReferencesEvenIfAliased">
            <summary>
            Specifies whether to find type references even if an alias is being used.
            Aliases may be <c>var</c> or <c>using Alias = ...;</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindOnlySpecializedReferences">
            <summary>
            Specifies whether find references should only look for specialized matches
            with equal type parameter substitution to the member we are searching for.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindCallsThroughVirtualBaseMethod">
            <summary>
            If this option is enabled, find references on a overridden member
            will find calls to the base member.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindCallsThroughInterface">
            <summary>
            If this option is enabled, find references on a member implementing
            an interface will also find calls to the interface.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.WholeVirtualSlot">
            <summary>
            If this option is enabled, find references will look for all references
            to the virtual method slot.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.SearchInDocumentationComments">
            <summary>
            Specifies whether to look for references in documentation comments.
            This will find entity references in <c>cref</c> attributes and
            parameter references in <c>&lt;param&gt;</c> and <c>&lt;paramref&gt;</c> tags.
            TODO: implement this feature.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.GetEffectiveAccessibility(ICSharpCode.NRefactory.TypeSystem.IEntity)">
            <summary>
            Gets the effective accessibility of the specified entity -
            that is, the accessibility viewed from the top level.
            </summary>
            <remarks>
            internal member in public class -> internal
            public member in internal class -> internal
            protected member in public class -> protected
            protected member in internal class -> protected and internal
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.GetInterestingFiles(ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope,ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Gets the file names that possibly contain references to the element being searched for.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindReferencesInFile(ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope,ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references in the given file.
            </summary>
            <param name="searchScope">The search scope for which to look.</param>
            <param name="resolver">AST resolver for the file to search in.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindReferencesInFile(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope},ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references in the given file.
            </summary>
            <param name="searchScopes">The search scopes for which to look.</param>
            <param name="resolver">AST resolver for the file to search in.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindReferencesInFile(ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references in the given file.
            </summary>
            <param name="searchScope">The search scope for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation for the project that contains the file.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindReferencesInFile(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope},ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references in the given file.
            </summary>
            <param name="searchScopes">The search scopes for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation for the project that contains the file.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindLocalReferences(ICSharpCode.NRefactory.TypeSystem.IVariable,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references of a given variable.
            </summary>
            <param name="variable">The variable for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindTypeParameterReferences(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references of a given type parameter.
            </summary>
            <param name="typeParameter">The type parameter for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope">
            <summary>
            Represents a scope in which references are searched.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.Compilation">
            <summary>
            Gets the compilation in which the entity being search for was defined.
            This is not necessarily the same compilation as is being searched in.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.SearchTerm">
            <summary>
            Gets the search term. Only files that contain this identifier need to be parsed.
            Can return null if all files need to be parsed.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.Accessibility">
            <summary>
            Gets the accessibility that defines the search scope.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.TopLevelTypeDefinition">
            <summary>
            Gets the top-level entity that defines the search scope.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.FileName">
            <summary>
            Gets the file name that defines the search scope.
            If null, all files are searched.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.GetNavigator(ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback)">
            <summary>
            Creates a navigator that can find references to this entity and reports
            them to the specified callback.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator">
            <summary>
            Allows controlling which nodes are resolved by the resolve visitor.
            </summary>
            <seealso cref="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor"/>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Asks the navigator whether to scan, skip, or resolve a node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator.Resolved(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Notifies the navigator that a node was resolved.
            </summary>
            <param name="node">The node that was resolved</param>
            <param name="result">Resolve result</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.Conversion,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Notifies the navigator that an implicit conversion was applied.
            </summary>
            <param name="expression">The expression that was resolved.</param>
            <param name="result">The resolve result of the expression.</param>
            <param name="conversion">The conversion applied to the expressed.</param>
            <param name="targetType">The target type of the conversion.</param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode">
            <summary>
            Represents the operation mode of the resolve visitor.
            </summary>
            <seealso cref="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor"/>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode.Scan">
            <summary>
            Scan into the children of the current node, without resolving the current node.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode.Skip">
            <summary>
            Skip the current node - do not scan into it; do not resolve it.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode.Resolve">
            <summary>
            Resolve the current node.
            Subnodes which are not required for resolving the current node
            will ask the navigator again whether they should be resolved.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult">
            <summary>
            Represents an anonymous method or lambda expression.
            Note: the lambda has no type.
            To retrieve the delegate type, look at the anonymous function conversion.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.HasParameterList">
            <summary>
            Gets whether there is a parameter list.
            This property always returns true for C# 3.0-lambdas, but may return false
            for C# 2.0 anonymous methods.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsAnonymousMethod">
            <summary>
            Gets whether this lambda is using the C# 2.0 anonymous method syntax.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsImplicitlyTyped">
            <summary>
            Gets whether the lambda parameters are implicitly typed.
            </summary>
            <remarks>This property returns false for anonymous methods without parameter list.</remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsAsync">
            <summary>
            Gets whether the lambda is async.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.GetInferredReturnType(ICSharpCode.NRefactory.TypeSystem.IType[])">
            <summary>
            Gets the return type inferred when the parameter types are inferred to be <paramref name="parameterTypes"/>
            </summary>
            <remarks>
            This method determines the return type inferred from the lambda body, which is used as part of C# type inference.
            Use the <see cref="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.ReturnType"/> property to retrieve the actual return type as determined by the target delegate type.
            </remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.Parameters">
            <summary>
            Gets the list of parameters.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.ReturnType">
            <summary>
            Gets the return type of the lambda.
            
            If the lambda is async, the return type includes <code>Task&lt;T&gt;</code>
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsValid(ICSharpCode.NRefactory.TypeSystem.IType[],ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions)">
            <summary>
            Gets whether the lambda body is valid for the given parameter types and return type.
            </summary>
            <returns>
            Produces a conversion with <see cref="P:ICSharpCode.NRefactory.Semantics.Conversion.IsAnonymousFunctionConversion"/>=<c>true</c> if the lambda is valid;
            otherwise returns <see cref="F:ICSharpCode.NRefactory.Semantics.Conversion.None"/>.
            </returns>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.Body">
            <summary>
            Gets the resolve result for the lambda body.
            Returns a resolve result for 'void' for statement lambdas.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.Log">
            <summary>
            Resolver logging helper.
            Wraps System.Diagnostics.Debug so that resolver-specific logging can be enabled/disabled on demand.
            (it's a huge amount of debug spew and slows down the resolver quite a bit)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup">
            <summary>
            Implementation of member lookup (C# 4.0 spec, §7.4).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsInvocable(ICSharpCode.NRefactory.TypeSystem.IMember)">
            <summary>
            Gets whether the member is considered to be invocable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsProtectedAccessAllowed(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Gets whether access to protected instance members of the target expression is possible.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsProtectedAccessAllowed(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether access to protected instance members of the target type is possible.
            </summary>
            <remarks>
            This method does not consider the special case of the 'base' reference. If possible, use the
            <c>IsProtectedAccessAllowed(ResolveResult)</c> overload instead.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsAccessible(ICSharpCode.NRefactory.TypeSystem.IEntity,System.Boolean)">
            <summary>
            Gets whether <paramref name="entity"/> is accessible in the current class.
            </summary>
            <param name="entity">The entity to test</param>
            <param name="allowProtectedAccess">
            Whether protected access to instance members is allowed.
            True if the type of the reference is derived from the current class.
            Protected static members may be accessible even if false is passed for this parameter.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.GetAccessibleMembers(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Retrieves all members that are accessible and not hidden (by being overridden or shadowed).
            Returns both members and nested type definitions. Does not include extension methods.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.Lookup(ICSharpCode.NRefactory.Semantics.ResolveResult,System.String,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean)">
            <summary>
            Performs a member lookup.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.LookupIndexers(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Looks up the indexers on the target type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.AddNestedTypes(ICSharpCode.NRefactory.TypeSystem.IType,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IType},System.Int32,System.Collections.Generic.List{ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.LookupGroup},System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IType}@,System.Collections.Generic.List{ICSharpCode.NRefactory.TypeSystem.IType}@)">
            <summary>
            Adds the nested types to 'newNestedTypes' and removes any hidden members from the existing lookup groups.
            </summary>
            <param name="type">Declaring type of the nested types</param>
            <param name="nestedTypes">List of nested types to add.</param>
            <param name="typeArgumentCount">The number of type arguments - used for hiding types from the base class</param>
            <param name="lookupGroups">List of existing lookup groups</param>
            <param name="typeBaseTypes">The base types of 'type' (initialized on demand)</param>
            <param name="newNestedTypes">The target list (created on demand).</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.AddMembers(ICSharpCode.NRefactory.TypeSystem.IType,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IMember},System.Boolean,System.Collections.Generic.List{ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.LookupGroup},System.Boolean,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IType}@,System.Collections.Generic.List{ICSharpCode.NRefactory.TypeSystem.IParameterizedMember}@,ICSharpCode.NRefactory.TypeSystem.IMember@)">
            <summary>
            Adds members to 'newMethods'/'newNonMethod'.
            Removes any members in the existing lookup groups that were hidden by added members.
            Substitutes 'virtual' members in the existing lookup groups for added 'override' members.
            </summary>
            <param name="type">Declaring type of the members</param>
            <param name="members">List of members to add.</param>
            <param name="allowProtectedAccess">Whether protected members are accessible</param>
            <param name="lookupGroups">List of existing lookup groups</param>
            <param name="treatAllParameterizedMembersAsMethods">Whether to treat properties as methods</param>
            <param name="typeBaseTypes">The base types of 'type' (initialized on demand)</param>
            <param name="newMethods">The target list for methods (created on demand).</param>
            <param name="newNonMethod">The target variable for non-method members.</param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.MethodListWithDeclaringType">
            <summary>
            A method list that belongs to a declaring type.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodListWithDeclaringType.DeclaringType">
            <summary>
            The declaring type.
            </summary>
            <remarks>
            Not all methods in this list necessarily have this as their declaring type.
            For example, this program:
            <code>
             class Base {
               public virtual void M() {}
             }
             class Derived : Base {
               public override void M() {}
               public void M(int i) {}
             }
            </code>
            results in two lists:
             <c>new MethodListWithDeclaringType(Base) { Derived.M() }</c>,
             <c>new MethodListWithDeclaringType(Derived) { Derived.M(int) }</c>
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult">
            <summary>
            Represents a group of methods.
            A method reference used to create a delegate is resolved to a MethodGroupResolveResult.
            The MethodGroupResolveResult has no type.
            To retrieve the delegate type or the chosen overload, look at the method group conversion.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TargetResult">
            <summary>
            Gets the resolve result for the target object.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TargetType">
            <summary>
            Gets the type of the reference to the target object.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.MethodName">
            <summary>
            Gets the name of the methods in this group.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.Methods">
            <summary>
            Gets the methods that were found.
            This list does not include extension methods.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.MethodsGroupedByDeclaringType">
            <summary>
            Gets the methods that were found, grouped by their declaring type.
            This list does not include extension methods.
            Base types come first in the list.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TypeArguments">
            <summary>
            Gets the type arguments that were explicitly provided.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.extensionMethods">
            <summary>
            List of extension methods, used to avoid re-calculating it in ResolveInvocation() when it was already
            calculated by ResolveMemberAccess().
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.GetExtensionMethods">
            <summary>
            Gets all candidate extension methods.
            Note: this includes candidates that are not eligible due to an inapplicable
            this argument.
            The candidates will only be specialized if the type arguments were provided explicitly.
            </summary>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.GetEligibleExtensionMethods(System.Boolean)">
            <summary>
            Gets the eligible extension methods.
            </summary>
            <param name="substituteInferredTypes">
            Specifies whether to produce a <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>
            when type arguments could be inferred from <see cref="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TargetType"/>.
            This setting is only used for inferred types and has no effect if the type parameters are
            specified explicitly.
            </param>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator">
            <summary>
            <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator"/> implementation that resolves a list of nodes.
            We will skip all nodes which are not the target nodes or ancestors of the target nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator.#ctor(ICSharpCode.NRefactory.CSharp.AstNode[])">
            <summary>
            Creates a new NodeListResolveVisitorNavigator that resolves the specified nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator.#ctor(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstNode},System.Boolean)">
            <summary>
            Creates a new NodeListResolveVisitorNavigator that resolves the specified nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <inheritdoc/>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution">
            <summary>
            C# overload resolution (C# 4.0 spec: §7.5).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.IsExpandedForm">
            <summary>
            Returns the normal form candidate, if this is an expanded candidate.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.ParameterTypes">
            <summary>
            Gets the parameter types. In the first step, these are the types without any substition.
            After type inference, substitutions will be performed.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.ArgumentToParameterMap">
            <summary>
            argument index -> parameter index; -1 for arguments that could not be mapped
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.Parameters">
            <summary>
            Gets the original member parameters (before any substitution!)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.TypeParameters">
            <summary>
            Gets the original method type parameters (before any substitution!)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.ArgumentConversions">
            <summary>
            Conversions applied to the arguments.
            This field is set by the CheckApplicability step.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.IsExtensionMethodInvocation">
            <summary>
            Gets/Sets whether the methods are extension methods that are being called using extension method syntax.
            </summary>
            <remarks>
            Setting this property to true restricts the possible conversions on the first argument to
            implicit identity, reference, or boxing conversions.
            </remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AllowExpandingParams">
            <summary>
            Gets/Sets whether expanding 'params' into individual elements is allowed.
            The default value is true.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AllowOptionalParameters">
            <summary>
            Gets/Sets whether optional parameters may be left at their default value.
            The default value is true.
            If this property is set to false, optional parameters will be treated like regular parameters.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.CheckForOverflow">
            <summary>
            Gets/Sets whether ConversionResolveResults created by this OverloadResolution
            instance apply overflow checking.
            The default value is false.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Arguments">
            <summary>
            Gets the arguments for which this OverloadResolution instance was created.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AddCandidate(ICSharpCode.NRefactory.TypeSystem.IParameterizedMember)">
            <summary>
            Adds a candidate to overload resolution.
            </summary>
            <param name="member">The candidate member to add.</param>
            <returns>The errors that prevent the member from being applicable, if any.
            Note: this method does not return errors that do not affect applicability.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AddCandidate(ICSharpCode.NRefactory.TypeSystem.IParameterizedMember,ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors)">
            <summary>
            Adds a candidate to overload resolution.
            </summary>
            <param name="member">The candidate member to add.</param>
            <param name="additionalErrors">Additional errors that apply to the candidate.
            This is used to represent errors during member lookup (e.g. OverloadResolutionErrors.Inaccessible)
            in overload resolution.</param>
            <returns>The errors that prevent the member from being applicable, if any.
            Note: this method does not return errors that do not affect applicability.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.CalculateCandidate(ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate)">
            <summary>
            Calculates applicability etc. for the candidate.
            </summary>
            <returns>True if the calculation was successful, false if the candidate should be removed without reporting an error</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AddMethodLists(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Resolver.MethodListWithDeclaringType})">
            <summary>
            Adds all candidates from the method lists.
            
            This method implements the logic that causes applicable methods in derived types to hide
            all methods in base types.
            </summary>
            <param name="methodLists">The methods, grouped by declaring type. Base types must come first in the list.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ValidateConstraints(ICSharpCode.NRefactory.TypeSystem.ITypeParameter,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.TypeVisitor)">
            <summary>
            Validates whether the given type argument satisfies the constraints for the given type parameter.
            </summary>
            <param name="typeParameter">The type parameter.</param>
            <param name="typeArgument">The type argument.</param>
            <param name="substitution">The substitution that defines how type parameters are replaced with type arguments.
            The substitution is used to check constraints that depend on other type parameters (or recursively on the same type parameter).
            May be null if no substitution should be used.</param>
            <returns>True if the constraints are satisfied; false otherwise.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.IsApplicable(ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors)">
            <summary>
            Returns whether a candidate with the given errors is still considered to be applicable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.BetterFunctionMember(ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate,ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate)">
            <summary>
            Returns 1 if c1 is better than c2; 2 if c2 is better than c1; or 0 if neither is better.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ILiftedOperator">
            <summary>
            Implement this interface to give overload resolution a hint that the member represents a lifted operator,
            which is used in the tie-breaking rules.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.BestCandidateErrors">
            <summary>
            Returns the errors that apply to the best candidate.
            This includes additional errors that do not affect applicability (e.g. AmbiguousMatch, MethodConstraintsNotSatisfied)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ArgumentConversions">
            <summary>
            Gets the implicit conversions that are being applied to the arguments.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.GetArgumentToParameterMap">
            <summary>
            Gets an array that maps argument indices to parameter indices.
            For arguments that could not be mapped to any parameter, the value will be -1.
            
            parameterIndex = GetArgumentToParameterMap()[argumentIndex]
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.GetArgumentsWithConversions">
            <summary>
            Returns the arguments for the method call in the order they were provided (not in the order of the parameters).
            Arguments are wrapped in a <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/> if an implicit conversion is being applied
            to them when calling the method.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.GetArgumentsWithConversionsAndNames">
            <summary>
            Returns the arguments for the method call in the order they were provided (not in the order of the parameters).
            Arguments are wrapped in a <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/> if an implicit conversion is being applied
            to them when calling the method.
            For arguments where an explicit argument name was provided, the argument will
            be wrapped in a <see cref="T:ICSharpCode.NRefactory.Semantics.NamedArgumentResolveResult"/>.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.CreateResolveResult(ICSharpCode.NRefactory.Semantics.ResolveResult,System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult},ICSharpCode.NRefactory.TypeSystem.IType)" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.TooManyPositionalArguments">
            <summary>
            Too many positional arguments (some could not be mapped to any parameter).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.NoParameterFoundForNamedArgument">
            <summary>
            A named argument could not be mapped to any parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.TypeInferenceFailed">
            <summary>
            Type inference failed for a generic method.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.WrongNumberOfTypeArguments">
            <summary>
            Type arguments were explicitly specified, but did not match the number of type parameters.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint">
            <summary>
            After substituting type parameters with the inferred types; a constructed type within the formal parameters
            does not satisfy its constraint.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.MissingArgumentForRequiredParameter">
            <summary>
            No argument was mapped to a non-optional parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.MultipleArgumentsForSingleParameter">
            <summary>
            Several arguments were mapped to a single (non-params-array) parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.ParameterPassingModeMismatch">
            <summary>
            'ref'/'out' passing mode doesn't match for at least 1 parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.ArgumentTypeMismatch">
            <summary>
            Argument type cannot be converted to parameter type
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.AmbiguousMatch">
            <summary>
            There is no unique best overload.
            This error does not apply to any single candidate, but only to the overall result of overload resolution.
            </summary>
            <remarks>
            This error does not prevent a candidate from being applicable.
            </remarks>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.Inaccessible">
            <summary>
            The member is not accessible.
            </summary>
            <remarks>
            This error is generated by member lookup; not by overload resolution.
            </remarks>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.MethodConstraintsNotSatisfied">
            <summary>
            A generic method 
            </summary>
            <remarks>
            This error does not prevent a candidate from being applicable.
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.RenameCallbackArguments">
            <summary>
            Arguments for the callback of <see cref="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.RenameReferencesInFile(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope},System.String,ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver,System.Action{ICSharpCode.NRefactory.CSharp.Resolver.RenameCallbackArguments},System.Action{ICSharpCode.NRefactory.TypeSystem.Error},System.Threading.CancellationToken)"/>.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveAtLocation">
            <summary>
            Helper class that resolves the node at a specified location.
            Can be used for implementing tool tips.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor">
            <summary>
            Traverses the DOM and resolves expressions.
            </summary>
            <remarks>
            The ResolveVisitor does two jobs at the same time: it tracks the resolve context (properties on CSharpResolver)
            and it resolves the expressions visited.
            To allow using the context tracking without having to resolve every expression in the file (e.g. when you want to resolve
            only a single node deep within the DOM), you can use the <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator"/> interface.
            The navigator allows you to switch the between scanning mode and resolving mode.
            In scanning mode, the context is tracked (local variables registered etc.), but nodes are not resolved.
            While scanning, the navigator will get asked about every node that the resolve visitor is about to enter.
            This allows the navigator whether to keep scanning, whether switch to resolving mode, or whether to completely skip the
            subtree rooted at that node.
            
            In resolving mode, the context is tracked and nodes will be resolved.
            The resolve visitor may decide that it needs to resolve other nodes as well in order to resolve the current node.
            In this case, those nodes will be resolved automatically, without asking the navigator interface.
            For child nodes that are not essential to resolving, the resolve visitor will switch back to scanning mode (and thus will
            ask the navigator for further instructions).
            
            Moreover, there is the <c>ResolveAll</c> mode - it works similar to resolving mode, but will not switch back to scanning mode.
            The whole subtree will be resolved without notifying the navigator.
            </remarks>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.currentQueryResult">
            <summary>Resolve result of the current LINQ query.</summary>
            <remarks>We do not have to put this into the stored state (resolver) because
            query expressions are always resolved in a single operation.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Creates a new ResolveVisitor instance.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ResetContext(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,System.Action)">
            <summary>
            Resets the visitor to the stored position, runs the action, and then reverts the visitor to the previous position.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Scans the AST rooted at the given node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.Resolve(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Equivalent to 'Scan', but also resolves the node at the same time.
            This method should be only used if the CSharpResolver passed to the ResolveVisitor was manually set
            to the correct state.
            Otherwise, use <c>resolver.Scan(syntaxTree); var result = resolver.GetResolveResult(node);</c>
            instead.
            --
            This method now is internal, because it is difficult to use correctly.
            Users of the public API should use Scan()+GetResolveResult() instead.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.Conversion,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Convert 'rr' to the target type using the specified conversion.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Convert 'rr' to the target type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ResolveAndProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Resolves the specified expression and processes the conversion to targetType.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetResolveResult(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets the resolve result for the specified node.
            If the node was not resolved by the navigator, this method will resolve it.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetResolverStateBefore(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets the resolver state in front of the specified node.
            If the node was not visited by a previous scanning process, the
            AST will be scanned again to determine the state.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetArguments(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression},System.String[]@)">
            <summary>
            Gets and resolves the arguments; unpacking any NamedArgumentExpressions.
            </summary>
            <remarks>
            Callers of GetArguments must also call either ProcessConversionsInInvocation or MarkUnknownNamedArguments
            to ensure the named arguments get resolved.
            Also, as named arguments get resolved by the parent node, the parent node must not scan
            into the argument list without being resolved - see NeedsResolvingDueToNamedArguments().
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.IsStaticResult(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Gets whether 'rr' is considered a static access on the target identifier.
            </summary>
            <param name="rr">Resolve Result of the MemberReferenceExpression</param>
            <param name="invocationRR">Resolve Result of the InvocationExpression</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ImplicitlyTypedLambda.GetAnyHypothesis">
            <summary>
            Get any hypothesis for this lambda.
            This method is used as fallback if the lambda isn't merged the normal way (AnonymousFunctionConversion)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.LambdaTypeHypothesis">
            <summary>
            Every possible set of parameter types gets its own 'hypothetical world'.
            It uses a nested ResolveVisitor that has its own resolve cache, so that resolve results cannot leave the hypothetical world.
            
            Only after overload resolution is applied and the actual parameter types are known, the winning hypothesis will be merged
            with the parent ResolveVisitor.
            This is done when the AnonymousFunctionConversion is applied on the parent visitor.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.WrapResult(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Wraps the result in an identity conversion.
            This is necessary so that '$from x in variable$ select x*2' does not resolve
            to the LocalResolveResult for the variable, which would confuse find references.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetSingleRangeVariable(ICSharpCode.NRefactory.CSharp.QueryExpression)">
            <summary>
            Gets the name of the range variable in the specified query.
            If the query has multiple range variables, this method returns null.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.TypeInferenceAlgorithm.CSharp4">
            <summary>
            C# 4.0 type inference.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.TypeInferenceAlgorithm.Improved">
            <summary>
            Improved algorithm (not part of any specification) using FindTypeInBounds for fixing.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.TypeInferenceAlgorithm.ImprovedReturnAllResults">
            <summary>
            Improved algorithm (not part of any specification) using FindTypeInBounds for fixing;
            uses <see cref="T:ICSharpCode.NRefactory.TypeSystem.IntersectionType"/> to report all results (in case of ambiguities).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference">
            <summary>
            Implements C# 4.0 Type Inference (§7.5.2).
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.Algorithm">
            <summary>
            Gets/Sets the type inference algorithm used.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.InferTypeArguments(System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.ITypeParameter},System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult},System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean@,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Performs type inference.
            </summary>
            <param name="typeParameters">The method type parameters that should be inferred.</param>
            <param name="arguments">The arguments passed to the method.</param>
            <param name="parameterTypes">The parameter types of the method.</param>
            <param name="success">Out: whether type inference was successful</param>
            <param name="classTypeArguments">
            Class type arguments. These are substituted for class type parameters in the formal parameter types
            when inferring a method group or lambda.
            </param>
            <returns>The inferred type arguments.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.InferTypeArgumentsFromBounds(System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.ITypeParameter},ICSharpCode.NRefactory.TypeSystem.IType,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean@)">
            <summary>
            Infers type arguments for the <paramref name="typeParameters"/> occurring in the <paramref name="targetType"/>
            so that the resulting type (after substition) satisfies the given bounds.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.MakeExactInference(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Make exact inference from U to V.
            C# 4.0 spec: §7.5.2.8 Exact inferences
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.MakeLowerBoundInference(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Make lower bound inference from U to V.
            C# 4.0 spec: §7.5.2.9 Lower-bound inferences
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.MakeUpperBoundInference(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Make upper bound inference from U to V.
            C# 4.0 spec: §7.5.2.10 Upper-bound inferences
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.GetBestCommonType(System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult},System.Boolean@)">
            <summary>
            Gets the best common type (C# 4.0 spec: §7.5.2.14) of a set of expressions.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.FindTypeInBounds(System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Finds a type that satisfies the given lower and upper bounds.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.AliasTypeResolveResult">
            <summary>
            Represents a type resolve result that's resolved using an alias.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.AliasTypeResolveResult.Alias">
            <summary>
            The alias used.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.AliasNamespaceResolveResult">
            <summary>
            Represents a namespace resolve result that's resolved using an alias.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.AliasNamespaceResolveResult.Alias">
            <summary>
            The alias used.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.Expression">
            <summary>
            Normal name lookup in expressions
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.InvocationTarget">
            <summary>
            Name lookup in expression, where the expression is the target of an invocation.
            Such a lookup will only return methods and delegate-typed fields.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.Type">
            <summary>
            Normal name lookup in type references.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.TypeInUsingDeclaration">
            <summary>
            Name lookup in the type reference inside a using declaration.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.BaseTypeReference">
            <summary>
            Name lookup for base type references.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.AliasNamespaceReference">
            <summary>
            Looks up an alias (identifier in front of :: operator).
            </summary>
            <remarks>
            The member lookup performed by the :: operator is handled
            by <see cref="T:ICSharpCode.NRefactory.CSharp.TypeSystem.MemberTypeOrNamespaceReference"/>.
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.AttributeTypeReference">
            <summary>
            Type reference used within an attribute.
            Looks up both 'withoutSuffix' and 'withSuffix' and returns the type that exists.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.ErrorConstantValue">
            <summary>
            Used for constants that could not be converted to IConstantValue.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.IncrementConstantValue">
            <summary>
            Increments an integer <see cref="T:ICSharpCode.NRefactory.TypeSystem.IConstantValue"/> by a fixed amount without changing the type.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.PrimitiveConstantExpression">
            <summary>
            C#'s equivalent to the SimpleConstantValue.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.ConstantArrayCreation">
            <summary>
            Represents an array creation (as used within an attribute argument)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.SizeOfConstantValue">
            <summary>
            Used for sizeof() expressions in constants.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpDocumentationComment">
            <summary>
            DocumentationComment with C# cref lookup.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile">
            <summary>
            Represents a file that was parsed and converted for the type system.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ResolvedUsingScope">
            <summary>
            Resolved version of using scope.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.ResolvedUsingScope.HasAlias(System.String)">
            <summary>
            Gets whether this using scope has an alias (either using or extern)
            with the specified name.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference">
            <summary>
            Represents a reference which could point to a type or namespace.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.Resolve(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Resolves the reference and returns the ResolveResult.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.ResolveType(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Returns the type that is referenced; or an <c>UnknownType</c> if the type isn't found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.ResolveNamespace(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Returns the namespace that is referenced; or null if no such namespace is found.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.MemberTypeOrNamespaceReference">
            <summary>
            Reference to a qualified type or namespace name.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.MemberTypeOrNamespaceReference.AddSuffix(System.String)">
            <summary>
            Adds a suffix to the identifier.
            Does not modify the existing type reference, but returns a new one.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.SimpleTypeOrNamespaceReference">
            <summary>
            Represents a simple C# name. (a single non-qualified identifier with an optional list of type arguments)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.SimpleTypeOrNamespaceReference.AddSuffix(System.String)">
            <summary>
            Adds a suffix to the identifier.
            Does not modify the existing type reference, but returns a new one.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor">
            <summary>
            Produces type and member definitions from the DOM.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.version">
            <summary>
            Version of the C# type system loader.
            Should be incremented when fixing bugs so that project contents cached on disk
            (which might be incorrect due to the bug) are re-created.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.InterningProvider">
            <summary>
            Gets/Sets the interning provider to use.
            The default value is a new <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SimpleInterningProvider"/> instance.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.SkipXmlDocumentation">
            <summary>
            Gets/Sets whether to ignore XML documentation.
            The default value is false.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.#ctor(System.String)">
            <summary>
            Creates a new TypeSystemConvertVisitor.
            </summary>
            <param name="fileName">The file name (used for DomRegions).</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.#ctor(ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedTypeDefinition)">
            <summary>
            Creates a new TypeSystemConvertVisitor and initializes it with a given context.
            </summary>
            <param name="unresolvedFile">The parsed file to which members should be added.</param>
            <param name="currentUsingScope">The current using scope.</param>
            <param name="currentTypeDefinition">The current type definition.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.AddDefaultMethodsToDelegate(ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultUnresolvedTypeDefinition,ICSharpCode.NRefactory.TypeSystem.ITypeReference,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IUnresolvedParameter})">
            <summary>
            Adds the 'Invoke', 'BeginInvoke', 'EndInvoke' methods, and a constructor, to the <paramref name="delegateType"/>.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope">
            <summary>
            Represents a scope that contains "using" statements.
            This is either the file itself, or a namespace declaration.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.#ctor">
            <summary>
            Creates a new root using scope.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.#ctor(ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope,System.String)">
            <summary>
            Creates a new nested using scope.
            </summary>
            <param name="parent">The parent using scope.</param>
            <param name="shortName">The short namespace name.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.HasAlias(System.String)">
            <summary>
            Gets whether this using scope has an alias (either using or extern)
            with the specified name.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.Resolve(ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Resolves the namespace represented by this using scope.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.PreProcessorDirective.Take">
            <summary>
            For an '#if' directive, specifies whether the condition evaluated to true.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TokenRole">
            <summary>
            A specific role only used for C# tokens
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TokenRole.Token">
            <summary>
            Gets the token as string. Note that the token Name and Token value may differ.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TokenRole.Length">
            <summary>
            Gets the char length of the token.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NewLineNode">
            <summary>
            A New line node represents a line break in the text.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.WhitespaceNode">
            <summary>
            A Whitespace node contains only whitespaces.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TextNode">
            <summary>
            A text node contains text without syntactic or semantic information.
            (non parseable part of a text)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory">
            <summary>
            The formatting options factory creates pre defined formatting option styles.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateEmpty">
            <summary>
            Creates empty CSharpFormatting options.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateMono">
            <summary>
            Creates mono indent style CSharpFormatting options.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateSharpDevelop">
            <summary>
            Creates sharp develop indent style CSharpFormatting options.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateKRStyle" -->
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateAllman">
            <summary>
            Creates allman indent style CSharpFormatting options used in Visual Studio.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateWhitesmiths">
            <summary>
            The Whitesmiths style, also called Wishart style to a lesser extent, is less common today than the previous three. It was originally used in the documentation for the first commercial C compiler, the Whitesmiths Compiler.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateGNU">
            <summary>
            Like the Allman and Whitesmiths styles, GNU style puts braces on a line by themselves, indented by 2 spaces,
            except when opening a function definition, where they are not indented.
            In either case, the contained code is indented by 2 spaces from the braces.
            Popularised by Richard Stallman, the layout may be influenced by his background of writing Lisp code.
            In Lisp the equivalent to a block (a progn) 
            is a first class data entity and giving it its own indent level helps to emphasize that,
            whereas in C a block is just syntax.
            Although not directly related to indentation, GNU coding style also includes a space before the bracketed 
            list of arguments to a function.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ReducedExtensionMethod">
            <summary>
            An invocated extension method hides the extension parameter in its parameter list.
            It's used to hide the internals of extension method invocation in certain situation to simulate the
            syntactic way of writing extension methods on semantic level.
            </summary>
        </member>
    </members>
</doc>
