<?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="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="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="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.IAstVisitor`2">
<summary>
AST visitor.
</summary>
</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="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="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="P:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.UnassignedVariableUses">
<summary>
Gets the unassigned usages of the previously analyzed variable.
</summary>
</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 CompilationUnit's file name.
If this node is not connected to a whole compilation, the file name will be null.
</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.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.GetText(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="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).
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.AstNode.DescendantsAndSelf">
<summary>
Gets all descendants of this node (including this node itself).
</summary>
</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="T:ICSharpCode.NRefactory.CSharp.AstType">
<summary>
A type reference in the C# AST.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.AstType.ToTypeReference(ICSharpCode.NRefactory.CSharp.NameLookupMode)">
<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.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)">
<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.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.Invoke(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="T:ICSharpCode.NRefactory.CSharp.DocumentationReference">
<summary>
Represents a 'cref' reference in XML documentation.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.EntityType">
<summary>
Gets/Sets the entity type.
Possible values are:
<c>EntityType.Operator</c> for operators,
<c>EntityType.Indexer</c> for indexers,
<c>EntityType.TypeDefinition</c> for references to primitive types,
and <c>EntityType.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 EntityType==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 EntityType==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 EntityType==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="M:ICSharpCode.NRefactory.CSharp.CompilationUnit.ToTypeSystem">
<summary>
Converts this compilation unit into a parsed file that can be stored in the type system.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.CompilationUnit.FileName">
<summary>
Gets/Sets the file name of this compilation unit.
</summary>
</member>
<!-- Badly formed XML comment ignored for member "P:ICSharpCode.NRefactory.CSharp.CompilationUnit.TopExpression" -->
<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.IAstVisitor">
<summary>
AST visitor.
</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.IAstVisitor`1">
<summary>
AST visitor.
</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.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)">
<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.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.Invoke(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.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 & 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 && 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 > right</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThanOrEqual">
<summary>left >= 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 < right</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThanOrEqual">
<summary>left <= 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 << right</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftRight">
<summary>left >> 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.EmptyExpression">
<summary>
Type<[EMPTY]>
</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="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="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<TypeParameters>(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<TypeParameters> : 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="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.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.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.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.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="M:ICSharpCode.NRefactory.CSharp.AstFormattingVisitor.ApplyChanges">
<summary>
Applies the changes to the input document.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.AstFormattingVisitor.ApplyChanges(ICSharpCode.NRefactory.CSharp.Refactoring.Script)">
<summary>
Applies the changes to the given Script instance.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor">
<summary>
Converts from C# AST to CodeDom.
</summary>
<remarks>
The conversion is intended for use in the SharpDevelop forms designer.
</remarks>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.Convert(ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.CompilationUnit,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpParsedFile)">
<summary>
Converts a compilation unit to CodeDom.
</summary>
<param name="compilationUnit">The input compilation unit.</param>
<param name="compilation">The current compilation.</param>
<param name="parsedFile">CSharpParsedFile, used for resolving.</param>
<returns>Converted CodeCompileUnit</returns>
<remarks>
This conversion process requires a resolver because it needs to distinguish field/property/event references etc.
</remarks>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.Convert(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver)">
<summary>
Converts a C# AST node to CodeDom.
</summary>
<param name="node">The input node.</param>
<param name="resolver">The AST resolver.</param>
<returns>The node converted into CodeDom</returns>
<remarks>
This conversion process requires a resolver because it needs to distinguish field/property/event references etc.
</remarks>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.MakeSnippetExpression(ICSharpCode.NRefactory.CSharp.Expression)">
<summary>
Converts an expression by storing it as C# snippet.
This is used for expressions that cannot be represented in CodeDom.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.UseFullyQualifiedTypeNames">
<summary>
Gets/Sets whether the visitor should use fully-qualified type references.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.CSharpAmbience">
<summary>
C# ambience.
</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="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="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="T:ICSharpCode.NRefactory.CSharp.IOutputFormatter">
<summary>
Output formatter for the Output visitor.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.IOutputFormatter.WriteIdentifier(System.String)">
<summary>
Writes an identifier.
If the identifier conflicts with a keyword, the output visitor will
call <c>WriteToken("@")</c> before calling WriteIdentifier().
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.IOutputFormatter.WriteKeyword(System.String)">
<summary>
Writes a keyword to the output.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.IOutputFormatter.WriteToken(System.String)">
<summary>
Writes a token to the output.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor">
<summary>
Outputs the AST.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.lastWritten">
<summary>
Used to insert the minimal amount of spaces so that the lexer recognizes the tokens that were written.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.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.CSharpOutputVisitor.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.CSharpOutputVisitor.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.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">
<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">
<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)">
<summary>
Writes a keyword, and all specials up to
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Semicolon">
<summary>
Marks the end of a statement
</summary>
</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.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.CSharpOutputVisitor.ConvertString(System.String)">
<summary>
Converts special characters to escape sequences within the given string.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.TextWriterOutputFormatter">
<summary>
Writes C# code into a TextWriter.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.CSharpParser.ParseSnippet(System.IO.TextReader)">
<summary>
Parses a file snippet; guessing what the code snippet represents (compilation unit, type members, block, type reference, expression).
</summary>
</member>
<member name="T:Mono.CSharp.MemberCore">
<summary>
Base representation for members. This is used to keep track
of Name, Location and Modifier flags, and handling Attributes.
</summary>
</member>
<member name="T:Mono.CSharp.Attributable">
<summary>
Base class for objects that can have Attributes applied to them.
</summary>
</member>
<member name="M:Mono.CSharp.Attributable.ApplyAttributeBuilder(Mono.CSharp.Attribute,Mono.CSharp.MethodSpec,System.Byte[],Mono.CSharp.PredefinedAttributes)">
<summary>
Use member-specific procedure to apply attribute @a in @cb to the entity being built in @builder
</summary>
</member>
<member name="P:Mono.CSharp.Attributable.AttributeTargets">
<summary>
Returns one AttributeTarget for this element.
</summary>
</member>
<member name="P:Mono.CSharp.Attributable.ValidAttributeTargets">
<summary>
Gets list of valid attribute targets for explicit target declaration.
The first array item is default target. Don't break this rule.
</summary>
</member>
<member name="F:Mono.CSharp.MemberCore.mod_flags">
<summary>
Modifier flags that the user specified in the source code
</summary>
</member>
<member name="F:Mono.CSharp.MemberCore.comment">
<summary>
XML documentation comment
</summary>
</member>
<member name="F:Mono.CSharp.MemberCore.caching_flags">
<summary>
MemberCore flags at first detected then cached
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.Emit">
<summary>
Base Emit method. This is also entry point for CLS-Compliant verification.
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.GetAttributeObsolete">
<summary>
Returns instance of ObsoleteAttribute for this MemberCore
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.CheckObsoleteness(Mono.CSharp.Location)">
<summary>
Checks for ObsoleteAttribute presence. It's used for testing of all non-types elements
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.IsClsComplianceRequired">
<summary>
Analyze whether CLS-Compliant verification must be execute for this MemberCore.
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.IsExposedFromAssembly">
<summary>
Returns true when MemberCore is exposed from assembly.
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.EnableOverloadChecks(Mono.CSharp.MemberCore)">
<summary>
Returns true when a member supports multiple overloads (methods, indexers, etc)
</summary>
</member>
<member name="M:Mono.CSharp.MemberCore.VerifyClsCompliance">
<summary>
The main virtual method for CLS-Compliant verifications.
The method returns true if member is CLS-Compliant and false if member is not
CLS-Compliant which means that CLS-Compliant tests are not necessary. A descendants override it
and add their extra verifications.
</summary>
</member>
<member name="P:Mono.CSharp.MemberCore.Location">
<summary>
Location where this declaration happens
</summary>
</member>
<member name="P:Mono.CSharp.MemberCore.DocCommentHeader">
<summary>
Represents header string for documentation comment
for each member types.
</summary>
</member>
<member name="P:Mono.CSharp.MemberCore.CLSAttributeValue">
<summary>
Goes through class hierarchy and gets value of first found CLSCompliantAttribute.
If no is attribute exists then assembly CLSCompliantAttribute is returned.
</summary>
</member>
<member name="P:Mono.CSharp.MemberCore.HasClsCompliantAttribute">
<summary>
Returns true if MemberCore is explicitly marked with CLSCompliantAttribute
</summary>
</member>
<!-- Badly formed XML comment ignored for member "F:Mono.CSharp.TypeDefinition.pending" -->
<member name="M:Mono.CSharp.TypeDefinition.AddIndexer(Mono.CSharp.Indexer)">
<summary>
Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
</summary>
</member>
<member name="M:Mono.CSharp.TypeDefinition.ResolveBaseTypes(Mono.CSharp.FullNamedExpression@)">
<summary>
This function computes the Base class and also the
list of interfaces that the class or struct @c implements.
The return value is an array (might be null) of
interfaces implemented (as Types).
The @base_class argument is set to the base object or null
if this is `System.Object'.
</summary>
</member>
<member name="M:Mono.CSharp.TypeDefinition.Define">
<summary>
Populates our TypeBuilder with fields and methods
</summary>
</member>
<member name="M:Mono.CSharp.TypeDefinition.VerifyImplements(Mono.CSharp.InterfaceMemberBase)">
<summary>
Performs checks for an explicit interface implementation. First it
checks whether the `interface_type' is a base inteface implementation.
Then it checks whether `name' exists in the interface type.
</summary>
</member>
<member name="P:Mono.CSharp.TypeDefinition.HasEquals">
<summary>
Method container contains Equals method
</summary>
</member>
<member name="P:Mono.CSharp.TypeDefinition.HasGetHashCode">
<summary>
Method container contains GetHashCode method
</summary>
</member>
<member name="M:Mono.CSharp.ClassOrStruct.DefineDefaultConstructor(System.Boolean)">
<summary>
Defines the default constructors
</summary>
</member>
<!-- Badly formed XML comment ignored for member "M:Mono.CSharp.Statement.Resolve(Mono.CSharp.BlockContext)" -->
<member name="M:Mono.CSharp.Statement.ResolveUnreachable(Mono.CSharp.BlockContext,System.Boolean)">
<summary>
We already know that the statement is unreachable, but we still
need to resolve it to catch errors.
</summary>
</member>
<member name="M:Mono.CSharp.Statement.DoEmit(Mono.CSharp.EmitContext)">
<summary>
Return value indicates whether all code paths emitted return.
</summary>
</member>
<member name="T:Mono.CSharp.Expression">
<remarks>
Base class for expressions
</remarks>
</member>
<member name="M:Mono.CSharp.Expression.DoResolve(Mono.CSharp.ResolveContext)">
<summary>
Performs semantic analysis on the Expression
</summary>
<remarks>
The Resolve method is invoked to perform the semantic analysis
on the node.
The return value is an expression (it can be the
same expression in some cases) or a new
expression that better represents this node.
For example, optimizations of Unary (LiteralInt)
would return a new LiteralInt with a negated
value.
If there is an error during semantic analysis,
then an error should be reported (using Report)
and a null value should be returned.
There are two side effects expected from calling
Resolve(): the the field variable "eclass" should
be set to any value of the enumeration
`ExprClass' and the type variable should be set
to a valid type (this is the type of the
expression).
</remarks>
</member>
<member name="M:Mono.CSharp.Expression.Resolve(Mono.CSharp.ResolveContext,Mono.CSharp.ResolveFlags)">
<summary>
Resolves an expression and performs semantic analysis on it.
</summary>
<remarks>
Currently Resolve wraps DoResolve to perform sanity
checking and assertion checking on what we expect from Resolve.
</remarks>
</member>
<member name="M:Mono.CSharp.Expression.Resolve(Mono.CSharp.ResolveContext)">
<summary>
Resolves an expression and performs semantic analysis on it.
</summary>
</member>
<member name="M:Mono.CSharp.Expression.ResolveLValue(Mono.CSharp.ResolveContext,Mono.CSharp.Expression)">
<summary>
Resolves an expression for LValue assignment
</summary>
<remarks>
Currently ResolveLValue wraps DoResolveLValue to perform sanity
checking and assertion checking on what we expect from Resolve
</remarks>
</member>
<member name="M:Mono.CSharp.Expression.Emit(Mono.CSharp.EmitContext)">
<summary>
Emits the code for the expression
</summary>
<remarks>
The Emit method is invoked to generate the code
for the expression.
</remarks>
</member>
<member name="M:Mono.CSharp.Expression.#ctor">
<summary>
Protected constructor. Only derivate types should
be able to be created
</summary>
</member>
<member name="M:Mono.CSharp.Expression.ExprClassFromMemberInfo(Mono.CSharp.MemberSpec,Mono.CSharp.Location)">
<summary>
Returns a fully formed expression after a MemberLookup
</summary>
</member>
<member name="M:Mono.CSharp.Expression.GetOperatorTrue(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.Location)">
<summary>
Returns an expression that can be used to invoke operator true
on the expression if it exists.
</summary>
</member>
<member name="M:Mono.CSharp.Expression.GetOperatorFalse(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.Location)">
<summary>
Returns an expression that can be used to invoke operator false
on the expression if it exists.
</summary>
</member>
<member name="M:Mono.CSharp.Expression.Error_UnexpectedKind(Mono.CSharp.IMemberContext,Mono.CSharp.Expression,System.String,System.String,Mono.CSharp.Location)">
<summary>
Reports that we were expecting `expr' to be of class `expected'
</summary>
</member>
<member name="T:Mono.CSharp.Assign">
<summary>
The Assign node takes care of assigning the value of source into
the expression represented by target.
</summary>
</member>
<member name="T:Mono.CSharp.ExpressionStatement">
<summary>
This is just a base class for expressions that can
appear on statements (invocations, object creation,
assignments, post/pre increment and decrement). The idea
being that they would support an extra Emition interface that
does not leave a result on the stack.
</summary>
</member>
<member name="M:Mono.CSharp.ExpressionStatement.EmitStatement(Mono.CSharp.EmitContext)">
<summary>
Requests the expression to be emitted in a `statement'
context. This means that no new value is left on the
stack after invoking this method (constrasted with
Emit that will always leave a value on the stack).
</summary>
</member>
<member name="M:Mono.CSharp.InterfaceMemberBase.FindBaseMember(Mono.CSharp.MemberSpec@,System.Boolean@)">
<summary>
Gets base method and its return type
</summary>
</member>
<member name="T:Mono.CSharp.IMethodData">
<summary>
Interface for MethodData class. Holds links to parent members to avoid member duplication.
</summary>
</member>
<member name="M:Mono.CSharp.MethodOrOperator.ConditionalConditions">
<summary>
Returns true if method has conditional attribute and the conditions is not defined (method is excluded).
</summary>
</member>
<member name="T:Mono.CSharp.IAssignMethod">
<summary>
This interface is implemented by expressions that can be assigned to.
</summary>
<remarks>
This interface is implemented by Expressions whose values can not
store the result on the top of the stack.
Expressions implementing this (Properties, Indexers and Arrays) would
perform an assignment of the Expression "source" into its final
location.
No values on the top of the stack are expected to be left by
invoking this method.
</remarks>
</member>
<member name="T:Mono.CSharp.LocalTemporary">
<summary>
An Expression to hold a temporary value.
</summary>
<remarks>
The LocalTemporary class is used to hold temporary values of a given
type to "simulate" the expression semantics. The local variable is
never captured.
The local temporary is used to alter the normal flow of code generation
basically it creates a local variable, and its emit instruction generates
code to access this value, return its address or save its value.
If `is_address' is true, then the value that we store is the address to the
real value, and not the value itself.
This is needed for a value type, because otherwise you just end up making a
copy of the value on the stack and modifying it. You really need a pointer
to the origional value so that you can modify it in that location. This
Does not happen with a class because a class is a pointer -- so you always
get the indirection.
</remarks>
</member>
<member name="T:Mono.CSharp.IMemoryLocation">
<summary>
This interface is implemented by variables
</summary>
</member>
<member name="M:Mono.CSharp.IMemoryLocation.AddressOf(Mono.CSharp.EmitContext,Mono.CSharp.AddressOp)">
<summary>
The AddressOf method should generate code that loads
the address of the object and leaves it on the stack.
The `mode' argument is used to notify the expression
of whether this will be used to read from the address or
write to the address.
This is just a hint that can be used to provide good error
reporting, and should have no other side effects.
</summary>
</member>
<member name="F:Mono.CSharp.ResolveContext.Switch">
<summary>
If this is non-null, points to the current switch statement
</summary>
</member>
<member name="F:Mono.CSharp.ResolveContext.Options.CheckedScope">
<summary>
This flag tracks the `checked' state of the compilation,
it controls whether we should generate code that does overflow
checking, or if we generate code that ignores overflows.
The default setting comes from the command line option to generate
checked or unchecked code plus any source code changes using the
checked/unchecked statements or expressions. Contrast this with
the ConstantCheckState flag.
</summary>
</member>
<member name="F:Mono.CSharp.ResolveContext.Options.ConstantCheckState">
<summary>
The constant check state is always set to `true' and cant be changed
from the command line. The source code can change this setting with
the `checked' and `unchecked' statements and expressions.
</summary>
</member>
<member name="F:Mono.CSharp.ResolveContext.Options.DoFlowAnalysis">
<summary>
Whether control flow analysis is enabled
</summary>
</member>
<member name="F:Mono.CSharp.ResolveContext.Options.OmitStructFlowAnalysis">
<summary>
Whether control flow analysis is disabled on structs
(only meaningful when DoFlowAnalysis is set)
</summary>
</member>
<member name="F:Mono.CSharp.ResolveContext.Options.ProbingMode">
Indicates the current context is in probing mode, no errors are reported.
</member>
<member name="T:Mono.CSharp.MemberAccess">
<summary>
Implements the member access expression
</summary>
</member>
<member name="T:Mono.CSharp.FullNamedExpression">
<summary>
Represents a namespace or a type. The name of the class was inspired by
section 10.8.1 (Fully Qualified Names).
</summary>
</member>
<member name="T:Mono.CSharp.Invocation">
<summary>
Invocation of methods or delegates.
</summary>
</member>
<member name="T:Mono.CSharp.MemberExpr">
<summary>
This class denotes an expression which evaluates to a member
of a struct or a class.
</summary>
</member>
<member name="M:Mono.CSharp.OverloadResolver.BetterFunction(Mono.CSharp.ResolveContext,Mono.CSharp.Arguments,Mono.CSharp.MemberSpec,Mono.CSharp.AParametersCollection,System.Boolean,Mono.CSharp.MemberSpec,Mono.CSharp.AParametersCollection,System.Boolean)">
<summary>
Determines "Better function" between candidate
and the current best match
</summary>
<remarks>
Returns a boolean indicating :
false if candidate ain't better
true if candidate is better than the current best match
</remarks>
</member>
<member name="P:Mono.CSharp.MemberExpr.Name">
<summary>
The name of this member.
</summary>
</member>
<member name="P:Mono.CSharp.MemberExpr.IsInstance">
<summary>
Whether this is an instance member.
</summary>
</member>
<member name="P:Mono.CSharp.MemberExpr.IsStatic">
<summary>
Whether this is a static member.
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.Error_AttributeEmitError(System.String)">
<summary>
This is rather hack. We report many emit attribute error with same error to be compatible with
csc. But because csc has to report them this way because error came from ilasm we needn't.
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.ResolveAttributeType">
<summary>
Tries to resolve the type of the attribute. Flags an error if it can't, and complain is true.
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.GetValidTargets">
<summary>
Get a string containing a list of valid targets for the attribute 'attr'
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.GetIndexerAttributeValue">
<summary>
Returns custom name of indexer
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.GetConditionalAttributeValue">
<summary>
Returns condition of ConditionalAttribute
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.GetObsoleteAttribute">
<summary>
Creates the instance of ObsoleteAttribute from this attribute instance
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.GetClsCompliantAttributeValue">
<summary>
Returns value of CLSCompliantAttribute contructor parameter but because the method can be called
before ApplyAttribute. We need to resolve the arguments.
This situation occurs when class deps is differs from Emit order.
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.IsSecurityActionValid">
<summary>
Tests permitted SecurityAction for assembly or other types
</summary>
</member>
<member name="M:Mono.CSharp.Attribute.ExtractSecurityPermissionSet(Mono.CSharp.MethodSpec,System.Collections.Generic.Dictionary{System.Security.Permissions.SecurityAction,System.Security.PermissionSet}@)">
<summary>
Creates instance of SecurityAttribute class and add result of CreatePermission method to permission table.
</summary>
<returns></returns>
</member>
<member name="M:Mono.CSharp.Attribute.Emit(System.Collections.Generic.Dictionary{Mono.CSharp.Attribute,System.Collections.Generic.List{Mono.CSharp.Attribute}})">
<summary>
Emit attribute for Attributable symbol
</summary>
</member>
<member name="M:Mono.CSharp.Attributes.CheckTargets">
<summary>
Checks whether attribute target is valid for the current element
</summary>
</member>
<member name="M:Mono.CSharp.Attributes.SearchMulti(Mono.CSharp.PredefinedAttribute)">
<summary>
Returns all attributes of type 't'. Use it when attribute is AllowMultiple = true
</summary>
</member>
<member name="T:Mono.CSharp.AttributeTester">
<summary>
Helper class for attribute verification routine.
</summary>
</member>
<member name="M:Mono.CSharp.AttributeTester.Report_ObsoleteMessage(System.ObsoleteAttribute,System.String,Mono.CSharp.Location,Mono.CSharp.Report)">
<summary>
Common method for Obsolete error/warning reporting.
</summary>
</member>
<member name="M:Mono.CSharp.ConstantFold.BinaryFold(Mono.CSharp.ResolveContext,Mono.CSharp.Binary.Operator,Mono.CSharp.Constant,Mono.CSharp.Constant,Mono.CSharp.Location)">
<summary>
Constant expression folder for binary operations.
Returns null if the expression can not be folded.
</summary>
</member>
<member name="M:Mono.CSharp.Class.ConditionalConditions">
Search for at least one defined condition in ConditionalAttribute of attribute class
Valid only for attribute classes.
</member>
<member name="T:Mono.CSharp.Interface">
<summary>
Interfaces
</summary>
</member>
<member name="F:Mono.CSharp.Interface.AllowedModifiers">
<summary>
Modifiers allowed in a class declaration
</summary>
</member>
<member name="T:Mono.CSharp.EmitContext">
<summary>
An Emit Context is created for each body of code (from methods,
properties bodies, indexer bodies or constructor bodies)
</summary>
</member>
<member name="F:Mono.CSharp.BuilderContext.Options.CheckedScope">
<summary>
This flag tracks the `checked' state of the compilation,
it controls whether we should generate code that does overflow
checking, or if we generate code that ignores overflows.
The default setting comes from the command line option to generate
checked or unchecked code plus any source code changes using the
checked/unchecked statements or expressions. Contrast this with
the ConstantCheckState flag.
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.return_type">
<summary>
The value that is allowed to be returned or NULL if there is no
return type.
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.temporary_storage">
<summary>
Keeps track of the Type to LocalBuilder temporary storage created
to store structures (used to compute the address of the structure
value on structure method invocations)
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.return_value">
<summary>
The location where we store the return value.
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.LoopBegin">
<summary>
Current loop begin and end labels.
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.LoopEnd">
<summary>
Current loop begin and end labels.
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.DefaultTarget">
<summary>
Default target in a switch statement. Only valid if
InSwitch is true
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.Switch">
<summary>
If this is non-null, points to the current switch statement
</summary>
</member>
<member name="F:Mono.CSharp.EmitContext.CurrentAnonymousMethod">
<summary>
Whether we are inside an anonymous method.
</summary>
</member>
<member name="M:Mono.CSharp.EmitContext.Mark(Mono.CSharp.Location)">
<summary>
This is called immediately before emitting an IL opcode to tell the symbol
writer to which source line this opcode belongs.
</summary>
</member>
<member name="M:Mono.CSharp.EmitContext.GetTemporaryLocal(Mono.CSharp.TypeSpec)">
<summary>
Returns a temporary storage for a variable of type t as
a local variable in the current body.
</summary>
</member>
<member name="M:Mono.CSharp.EmitContext.TemporaryReturn">
<summary>
ReturnValue creates on demand the LocalBuilder for the
return value from the function. By default this is not
used. This is only required when returns are found inside
Try or Catch statements.
This method is typically invoked from the Emit phase, so
we allow the creation of a return label if it was not
requested during the resolution phase. Could be cleaned
up, but it would replicate a lot of logic in the Emit phase
of the code that uses it.
</summary>
</member>
<member name="M:Mono.CSharp.Const.Define">
<summary>
Defines the constant in the @parent
</summary>
</member>
<member name="M:Mono.CSharp.Const.Emit">
<summary>
Emits the field value by evaluating the expression
</summary>
</member>
<member name="T:Mono.CSharp.Constant">
<summary>
Base class for constants and literals.
</summary>
</member>
<member name="M:Mono.CSharp.Constant.GetValue">
<summary>
This is used to obtain the actual value of the literal
cast into an object.
</summary>
</member>
<member name="M:Mono.CSharp.Constant.ConvertExplicitly(System.Boolean,Mono.CSharp.TypeSpec)">
<summary>
Maybe ConvertTo name is better. It tries to convert `this' constant to target_type.
It throws OverflowException
</summary>
</member>
<member name="M:Mono.CSharp.Constant.TryReduce(Mono.CSharp.ResolveContext,Mono.CSharp.TypeSpec)">
<summary>
Attempts to do a compile-time folding of a constant cast.
</summary>
</member>
<member name="M:Mono.CSharp.Constant.IsDefaultInitializer(Mono.CSharp.TypeSpec)">
<summary>
Need to pass type as the constant can require a boxing
and in such case no optimization is possible
</summary>
</member>
<member name="M:Mono.CSharp.IntConstant.TryImplicitIntConversion(Mono.CSharp.TypeSpec)">
<summary>
Attempts to perform an implicit constant conversion of the IntConstant
into a different data type using casts (See Implicit Constant
Expression Conversions)
</summary>
</member>
<member name="T:Mono.CSharp.SideEffectConstant">
<summary>
The value is constant, but when emitted has a side effect. This is
used by BitwiseAnd to ensure that the second expression is invoked
regardless of the value of the left side.
</summary>
</member>
<member name="M:Mono.CSharp.CloneContext.RemapBlockCopy(Mono.CSharp.Block)">
Remaps block to cloned copy if one exists.
</member>
<member name="M:Mono.CSharp.Convert.ImplicitNumericConversion(Mono.CSharp.Expression,Mono.CSharp.TypeSpec)">
<summary>
Implicit Numeric Conversions.
expr is the expression to convert, returns a new expression of type
target_type or null if an implicit conversion is not possible.
</summary>
</member>
<member name="M:Mono.CSharp.Convert.FindMostEncompassedType(System.Collections.Generic.IList{Mono.CSharp.TypeSpec})">
<summary>
Finds "most encompassed type" according to the spec (13.4.2)
amongst the methods in the MethodGroupExpr
</summary>
</member>
<member name="M:Mono.CSharp.Convert.FindMostSpecificTarget(System.Collections.Generic.IList{Mono.CSharp.MethodSpec},Mono.CSharp.TypeSpec,System.Boolean)">
<summary>
Finds the most specific target Tx according to section 13.4.4
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ImplicitUserConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
User-defined Implicit conversions
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitUserConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
User-defined Explicit conversions
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ImplicitConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Converts implicitly the resolved expression `expr' into the
`target_type'. It returns a new expression that can be used
in a context that expects a `target_type'.
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ImplicitConversionStandard(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Attempts to apply the `Standard Implicit
Conversion' rules to the expression `expr' into
the `target_type'. It returns a new expression
that can be used in a context that expects a
`target_type'.
This is different from `ImplicitConversion' in that the
user defined implicit conversions are excluded.
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ImplicitConversionRequired(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Attempts to implicitly convert `source' into `target_type', using
ImplicitConversion. If there is no implicit conversion, then
an error is signaled
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitNumericConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec)">
<summary>
Performs the explicit numeric conversions
There are a few conversions that are not part of the C# standard,
they were interim hacks in the C# compiler that were supposed to
become explicit operators in the UIntPtr class and IntPtr class,
but for historical reasons it did not happen, so the C# compiler
ended up with these special hacks.
See bug 59800 for details.
The conversion are:
UIntPtr->SByte
UIntPtr->Int16
UIntPtr->Int32
IntPtr->UInt64
UInt64->IntPtr
SByte->UIntPtr
Int16->UIntPtr
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitReferenceConversionExists(Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
<summary>
Returns whether an explicit reference conversion can be performed
from source_type to target_type
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitReferenceConversion(Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
<summary>
Implements Explicit Reference conversions
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitConversionCore(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Performs an explicit conversion of the expression `expr' whose
type is expr.Type to `target_type'.
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitConversionStandard(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Same as ExplicitConversion, only it doesn't include user defined conversions
</summary>
</member>
<member name="M:Mono.CSharp.Convert.ExplicitConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Performs an explicit conversion of the expression `expr' whose
type is expr.Type to `target_type'.
</summary>
</member>
<member name="T:Mono.CSharp.CSharpParser">
<summary>
The C# Parser
</summary>
</member>
<member name="F:Mono.CSharp.CSharpParser.yyFinal">
debugging support, requires the package jay.yydebug.
Set to null to suppress debugging messages.
</member>
<member name="F:Mono.CSharp.CSharpParser.current_block">
<summary>
Current block is used to add statements as we find
them.
</summary>
</member>
<member name="F:Mono.CSharp.CSharpParser.current_local_parameters">
<summary>
This is used by the unary_expression code to resolve
a name against a parameter.
</summary>
</member>
<member name="F:Mono.CSharp.CSharpParser.oob_stack">
An out-of-band stack.
</member>
<member name="F:Mono.CSharp.CSharpParser.yacc_verbose_flag">
Controls the verbosity of the errors produced by the parser
</member>
<member name="F:Mono.CSharp.CSharpParser.UnexpectedEOF">
Used by the interactive shell, flags whether EOF was reached
and an error was produced
</member>
<member name="F:Mono.CSharp.CSharpParser.file">
The current file.
</member>
<member name="F:Mono.CSharp.CSharpParser.tmpComment">
Temporary Xml documentation cache.
For enum types, we need one more temporary store.
</member>
<member name="F:Mono.CSharp.CSharpParser.current_attr_target">
Current attribute target
</member>
<member name="F:Mono.CSharp.CSharpParser.InteractiveResult">
When using the interactive parser, this holds the
resulting expression
</member>
<member name="F:Mono.CSharp.CSharpParser.ErrorOutput">
error output stream.
It should be changeable.
</member>
<member name="M:Mono.CSharp.CSharpParser.yyerror(System.String)">
simplified error message.
@see <a href="#yyerror(java.lang.String, java.lang.String[])">yyerror</a>
</member>
<member name="M:Mono.CSharp.CSharpParser.yyerror(System.String,System.String[])">
(syntax) error message.
Can be overwritten to control message format.
@param message text to be displayed.
@param expected vector of acceptable tokens, if available.
</member>
<member name="F:Mono.CSharp.CSharpParser.yyExpectingState">
index-checked interface to yyNames[].
@param token single character or %token value.
@return token name or [illegal] or [unknown].
</member>
<member name="M:Mono.CSharp.CSharpParser.yyExpectingTokens(System.Int32)">
computes list of expected tokens on error by tracing the tables.
@param state for which to compute the list.
@return list of token names.
</member>
<member name="M:Mono.CSharp.CSharpParser.yyparse(Mono.CSharp.yyParser.yyInput,System.Object)">
the generated parser, with debugging messages.
Maintains a state and a value stack, currently with fixed maximum size.
@param yyLex scanner.
@param yydebug debug message writer implementing yyDebug, or null.
@return result of the last reduction, if any.
@throws yyException on irrecoverable parse error.
</member>
<member name="F:Mono.CSharp.CSharpParser.yyMax">
initial size and increment of the state/value stack [default 256].
This is not final so that it can be overwritten outside of invocations
of yyparse().
</member>
<member name="M:Mono.CSharp.CSharpParser.yyDefault(System.Object)">
executed at the beginning of a reduce action.
Used as $$ = yyDefault($1), prior to the user-specified action, if any.
Can be overwritten to provide deep copy, etc.
@param first value for $1, or null.
@return first.
</member>
<member name="M:Mono.CSharp.CSharpParser.yyparse(Mono.CSharp.yyParser.yyInput)">
the generated parser.
Maintains a state and a value stack, currently with fixed maximum size.
@param yyLex scanner.
@return result of the last reduction, if any.
@throws yyException on irrecoverable parse error.
</member>
<member name="T:Mono.CSharp.yyParser.yyException">
thrown for irrecoverable syntax errors and stack overflow.
</member>
<member name="T:Mono.CSharp.yyParser.yyInput">
must be implemented by a scanner object to supply input to the parser.
</member>
<member name="M:Mono.CSharp.yyParser.yyInput.advance">
move on to next token.
@return false if positioned beyond tokens.
@throws IOException on input error.
</member>
<member name="M:Mono.CSharp.yyParser.yyInput.token">
classifies current token.
Should not be called if advance() returned false.
@return current %token or single character.
</member>
<member name="M:Mono.CSharp.yyParser.yyInput.value">
associated with current token.
Should not be called if advance() returned false.
@return value for token().
</member>
<member name="T:Mono.CSharp.Tokenizer">
<summary>
Tokenizer for C# source code.
</summary>
</member>
<member name="M:Mono.CSharp.Tokenizer.ParsePragmaDirective(System.String)">
<summary>
Handles #pragma directive
</summary>
</member>
<member name="T:Mono.CSharp.Driver">
<summary>
The compiler driver.
</summary>
</member>
<member name="T:Mono.CSharp.TypeExpr">
<summary>
Expression that evaluates to a type
</summary>
</member>
<member name="T:Mono.CSharp.EnumConstant">
<summary>
This class is used to wrap literals which belong inside Enums
</summary>
</member>
<member name="T:Mono.CSharp.ExprClass">
<remarks>
The ExprClass class contains the is used to pass the
classification of an expression (value, variable, namespace,
type, method group, property access, event access, indexer access,
nothing).
</remarks>
</member>
<member name="T:Mono.CSharp.ResolveFlags">
<remarks>
This is used to tell Resolve in which types of expressions we're
interested.
</remarks>
</member>
<member name="T:Mono.CSharp.TypeCast">
<summary>
This kind of cast is used to encapsulate the child
whose type is child.Type into an expression that is
reported to return "return_type". This is used to encapsulate
expressions which have compatible types, but need to be dealt
at higher levels with.
For example, a "byte" expression could be encapsulated in one
of these as an "unsigned int". The type for the expression
would be "unsigned int".
</summary>
</member>
<member name="T:Mono.CSharp.BoxedCast">
<summary>
This kind of cast is used to encapsulate Value Types in objects.
The effect of it is to box the value type emitted by the previous
operation.
</summary>
</member>
<member name="T:Mono.CSharp.ConvCast">
<summary>
This is used to perform explicit numeric conversions.
Explicit numeric conversions might trigger exceptions in a checked
context, so they should generate the conv.ovf opcodes instead of
conv opcodes.
</summary>
</member>
<member name="T:Mono.CSharp.ClassCast">
<summary>
This kind of cast is used to encapsulate a child and cast it
to the class requested
</summary>
</member>
<member name="T:Mono.CSharp.SimpleName">
<summary>
SimpleName expressions are formed of a single word and only happen at the beginning
of a dotted-name.
</summary>
</member>
<member name="T:Mono.CSharp.TypeExpression">
<summary>
Fully resolved Expression that already evaluated to a type
</summary>
</member>
<member name="T:Mono.CSharp.MethodGroupExpr">
<summary>
MethodGroupExpr represents a group of method candidates which
can be resolved to the best method overload
</summary>
</member>
<member name="M:Mono.CSharp.MethodGroupExpr.OverloadResolve(Mono.CSharp.ResolveContext,Mono.CSharp.Arguments@,Mono.CSharp.OverloadResolver.IErrorHandler,Mono.CSharp.OverloadResolver.Restrictions)">
<summary>
Find the Applicable Function Members (7.4.2.1)
me: Method Group expression with the members to select.
it might contain constructors or methods (or anything
that maps to a method).
Arguments: ArrayList containing resolved Argument objects.
loc: The location if we want an error to be reported, or a Null
location for "probing" purposes.
Returns: The MethodBase (either a ConstructorInfo or a MethodInfo)
that is the best match of me on Arguments.
</summary>
</member>
<member name="T:Mono.CSharp.EventExpr">
<summary>
Fully resolved expression that evaluates to an Event
</summary>
</member>
<member name="T:Mono.CSharp.VarExpr">
Handles `var' contextual keyword; var becomes a keyword only
if no type called var exists in a variable scope
</member>
<member name="T:Mono.CSharp.Enum">
<summary>
Enumeration container
</summary>
</member>
<member name="T:Mono.CSharp.Evaluator">
<summary>
Evaluator: provides an API to evaluate C# statements and
expressions dynamically.
</summary>
<remarks>
This class exposes static methods to evaluate expressions in the
current program.
To initialize the evaluator with a number of compiler
options call the Init(string[]args) method with a set of
command line options that the compiler recognizes.
To interrupt execution of a statement, you can invoke the
Evaluator.Interrupt method.
</remarks>
</member>
<member name="F:Mono.CSharp.Evaluator.DescribeTypeExpressions">
<summary>
If true, turns type expressions into valid expressions
and calls the describe method on it
</summary>
</member>
<member name="F:Mono.CSharp.Evaluator.Terse">
<summary>
Whether the evaluator will use terse syntax, and the semicolons at the end are optional
</summary>
</member>
<member name="M:Mono.CSharp.Evaluator.Interrupt">
<summary>
Interrupts the evaluation of an expression executing in Evaluate.
</summary>
<remarks>
Use this method to interrupt long-running invocations.
</remarks>
</member>
<member name="M:Mono.CSharp.Evaluator.Compile(System.String,Mono.CSharp.CompiledMethod@)">
<summary>
Compiles the input string and returns a delegate that represents the compiled code.
</summary>
<remarks>
Compiles the input string as a C# expression or
statement, unlike the Evaluate method, the
resulting delegate can be invoked multiple times
without incurring in the compilation overhead.
If the return value of this function is null,
this indicates that the parsing was complete.
If the return value is a string it indicates
that the input string was partial and that the
invoking code should provide more code before
the code can be successfully compiled.
If you know that you will always get full expressions or
statements and do not care about partial input, you can use
the other Compile overload.
On success, in addition to returning null, the
compiled parameter will be set to the delegate
that can be invoked to execute the code.
</remarks>
</member>
<member name="M:Mono.CSharp.Evaluator.Compile(System.String)">
<summary>
Compiles the input string and returns a delegate that represents the compiled code.
</summary>
<remarks>
Compiles the input string as a C# expression or
statement, unlike the Evaluate method, the
resulting delegate can be invoked multiple times
without incurring in the compilation overhead.
This method can only deal with fully formed input
strings and does not provide a completion mechanism.
If you must deal with partial input (for example for
interactive use) use the other overload.
On success, a delegate is returned that can be used
to invoke the method.
</remarks>
</member>
<member name="M:Mono.CSharp.Evaluator.Evaluate(System.String,System.Object@,System.Boolean@)">
<summary>
Evaluates and expression or statement and returns any result values.
</summary>
<remarks>
Evaluates the input string as a C# expression or
statement. If the input string is an expression
the result will be stored in the result variable
and the result_set variable will be set to true.
It is necessary to use the result/result_set
pair to identify when a result was set (for
example, execution of user-provided input can be
an expression, a statement or others, and
result_set would only be set if the input was an
expression.
If the return value of this function is null,
this indicates that the parsing was complete.
If the return value is a string, it indicates
that the input is partial and that the user
should provide an updated string.
</remarks>
</member>
<member name="M:Mono.CSharp.Evaluator.Run(System.String)">
<summary>
Executes the given expression or statement.
</summary>
<remarks>
Executes the provided statement, returns true
on success, false on parsing errors. Exceptions
might be thrown by the called code.
</remarks>
</member>
<member name="M:Mono.CSharp.Evaluator.Evaluate(System.String)">
<summary>
Evaluates and expression or statement and returns the result.
</summary>
<remarks>
Evaluates the input string as a C# expression or
statement and returns the value.
This method will throw an exception if there is a syntax error,
of if the provided input is not an expression but a statement.
</remarks>
</member>
<member name="M:Mono.CSharp.Evaluator.LoadAssembly(System.String)">
<summary>
Loads the given assembly and exposes the API to the user.
</summary>
</member>
<member name="M:Mono.CSharp.Evaluator.ReferenceAssembly(System.Reflection.Assembly)">
<summary>
Exposes the API of the given assembly to the Evaluator
</summary>
</member>
<member name="P:Mono.CSharp.Evaluator.InteractiveBaseClass">
<summary>
The base class for the classes that host the user generated code
</summary>
<remarks>
This is the base class that will host the code
executed by the Evaluator. By default
this is the Mono.CSharp.InteractiveBase class
which is useful for interactive use.
By changing this property you can control the
base class and the static members that are
available to your evaluated code.
</remarks>
</member>
<member name="T:Mono.CSharp.Evaluator.QuitValue">
<summary>
A sentinel value used to indicate that no value was
was set by the compiled function. This is used to
differentiate between a function not returning a
value and null.
</summary>
</member>
<member name="T:Mono.CSharp.CompiledMethod">
<summary>
A delegate that can be used to invoke the
compiled expression or statement.
</summary>
<remarks>
Since the Compile methods will compile
statements and expressions into the same
delegate, you can tell if a value was returned
by checking whether the returned value is of type
NoValueSet.
</remarks>
</member>
<member name="T:Mono.CSharp.InteractiveBase">
<summary>
The default base class for every interaction line
</summary>
<remarks>
The expressions and statements behave as if they were
a static method of this class. The InteractiveBase class
contains a number of useful methods, but can be overwritten
by setting the InteractiveBaseType property in the Evaluator
</remarks>
</member>
<member name="F:Mono.CSharp.InteractiveBase.Output">
<summary>
Determines where the standard output of methods in this class will go.
</summary>
</member>
<member name="F:Mono.CSharp.InteractiveBase.Error">
<summary>
Determines where the standard error of methods in this class will go.
</summary>
</member>
<member name="F:Mono.CSharp.InteractiveBase.Prompt">
<summary>
The primary prompt used for interactive use.
</summary>
</member>
<member name="F:Mono.CSharp.InteractiveBase.ContinuationPrompt">
<summary>
The secondary prompt used for interactive use (used when
an expression is incomplete).
</summary>
</member>
<member name="F:Mono.CSharp.InteractiveBase.QuitRequested">
<summary>
Used to signal that the user has invoked the `quit' statement.
</summary>
</member>
<member name="M:Mono.CSharp.InteractiveBase.ShowVars">
<summary>
Shows all the variables defined so far.
</summary>
</member>
<member name="M:Mono.CSharp.InteractiveBase.ShowUsing">
<summary>
Displays the using statements in effect at this point.
</summary>
</member>
<member name="M:Mono.CSharp.InteractiveBase.Time(System.Action)">
<summary>
Times the execution of the given delegate
</summary>
</member>
<member name="M:Mono.CSharp.InteractiveBase.LoadPackage(System.String)">
<summary>
Loads the assemblies from a package
</summary>
<remarks>
Loads the assemblies from a package. This is equivalent
to passing the -pkg: command line flag to the C# compiler
on the command line.
</remarks>
</member>
<member name="M:Mono.CSharp.InteractiveBase.LoadAssembly(System.String)">
<summary>
Loads the assembly
</summary>
<remarks>
Loads the specified assembly and makes its types
available to the evaluator. This is equivalent
to passing the -pkg: command line flag to the C#
compiler on the command line.
</remarks>
</member>
<member name="M:Mono.CSharp.InteractiveBase.Quit">
<summary>
Same as quit - useful in script scenerios
</summary>
</member>
<member name="M:Mono.CSharp.InteractiveBase.Describe(System.Object)">
<summary>
Describes an object or a type.
</summary>
<remarks>
This method will show a textual representation
of the object's type. If the object is a
System.Type it renders the type directly,
otherwise it renders the type returned by
invoking GetType on the object.
</remarks>
</member>
<member name="P:Mono.CSharp.InteractiveBase.help">
<summary>
Returns a list of available static methods.
</summary>
</member>
<member name="P:Mono.CSharp.InteractiveBase.quit">
<summary>
Indicates to the read-eval-print-loop that the interaction should be finished.
</summary>
</member>
<member name="T:Mono.CSharp.OptionalAssign">
<summary>
A class used to assign values if the source expression is not void
Used by the interactive shell to allow it to call this code to set
the return value for an invocation.
</summary>
</member>
<member name="T:Mono.CSharp.UnaryMutator">
<summary>
Unary Mutator expressions (pre and post ++ and --)
</summary>
<remarks>
UnaryMutator implements ++ and -- expressions. It derives from
ExpressionStatement becuase the pre/post increment/decrement
operators can be used in a statement context.
FIXME: Idea, we could split this up in two classes, one simpler
for the common case, and one with the extra fields for more complex
classes (indexers require temporary access; overloaded require method)
</remarks>
</member>
<member name="T:Mono.CSharp.Is">
<summary>
Implementation of the `is' operator.
</summary>
</member>
<member name="T:Mono.CSharp.As">
<summary>
Implementation of the `as' operator.
</summary>
</member>
<member name="T:Mono.CSharp.Binary">
<summary>
Binary operators
</summary>
</member>
<member name="M:Mono.CSharp.Binary.OperName(Mono.CSharp.Binary.Operator)">
<summary>
Returns a stringified representation of the Operator
</summary>
</member>
<member name="M:Mono.CSharp.Binary.EmitBranchable(Mono.CSharp.EmitContext,System.Reflection.Emit.Label,System.Boolean)">
<remarks>
EmitBranchable is called from Statement.EmitBoolExpression in the
context of a conditional bool expression. This function will return
false if it is was possible to use EmitBranchable, or true if it was.
The expression's code is generated, and we will generate a branch to `target'
if the resulting expression value is equal to isTrue
</remarks>
</member>
<member name="T:Mono.CSharp.Conditional">
<summary>
Implements the ternary conditional operator (?:)
</summary>
</member>
<member name="T:Mono.CSharp.ParameterReference">
<summary>
This represents a reference to a parameter in the intermediate
representation.
</summary>
</member>
<member name="M:Mono.CSharp.New.Constantify(Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Converts complex core type syntax like 'new int ()' to simple constant
</summary>
</member>
<member name="T:Mono.CSharp.ArrayCreation">
<summary>
14.5.10.2: Represents an array creation expression.
</summary>
<remarks>
There are two possible scenarios here: one is an array creation
expression that specifies the dimensions and optionally the
initialization data and the other which does not need dimensions
specified but where initialization data is mandatory.
</remarks>
</member>
<member name="T:Mono.CSharp.This">
<summary>
Represents the `this' construct
</summary>
</member>
<member name="T:Mono.CSharp.ArglistAccess">
<summary>
Represents the `__arglist' construct
</summary>
</member>
<member name="T:Mono.CSharp.Arglist">
<summary>
Represents the `__arglist (....)' construct
</summary>
</member>
<member name="T:Mono.CSharp.TypeOf">
<summary>
Implements the typeof operator
</summary>
</member>
<member name="T:Mono.CSharp.SizeOf">
<summary>
Implements the sizeof expression
</summary>
</member>
<member name="T:Mono.CSharp.QualifiedAliasMember">
<summary>
Implements the qualified-alias-member (::) expression.
</summary>
</member>
<member name="T:Mono.CSharp.CheckedExpr">
<summary>
Implements checked expressions
</summary>
</member>
<member name="T:Mono.CSharp.UnCheckedExpr">
<summary>
Implements the unchecked expression
</summary>
</member>
<member name="T:Mono.CSharp.ElementAccess">
<summary>
An Element Access expression.
During semantic analysis these are transformed into
IndexerAccess, ArrayAccess or a PointerArithmetic.
</summary>
</member>
<member name="T:Mono.CSharp.ArrayAccess">
<summary>
Implements array access
</summary>
</member>
<member name="T:Mono.CSharp.EmptyExpression">
<summary>
This class exists solely to pass the Type around and to be a dummy
that can be passed to the conversion functions (this is used by
foreach implementation to typecast the object return value from
get_Current into the proper type. All code has been generated and
we only care about the side effect conversions to be performed
This is also now used as a placeholder where a no-action expression
is needed (the `New' class).
</summary>
</member>
<member name="T:Mono.CSharp.FixedField">
<summary>
Fixed buffer implementation
</summary>
</member>
<member name="T:Mono.CSharp.TypeParameterExpr">
<summary>
A TypeExpr which already resolved to a type parameter.
</summary>
</member>
<member name="M:Mono.CSharp.TypeArguments.Resolve(Mono.CSharp.IMemberContext)">
<summary>
Resolve the type arguments.
</summary>
</member>
<member name="P:Mono.CSharp.TypeArguments.Arguments">
<summary>
We may only be used after Resolve() is called and return the fully
resolved types.
</summary>
</member>
<member name="M:Mono.CSharp.GenericTypeExpr.#ctor(Mono.CSharp.TypeSpec,Mono.CSharp.TypeArguments,Mono.CSharp.Location)">
<summary>
Instantiate the generic type `t' with the type arguments `args'.
Use this constructor if you already know the fully resolved
generic type.
</summary>
</member>
<member name="M:Mono.CSharp.TypeManager.CSharpName(Mono.CSharp.TypeSpec)">
<summary>
Returns the C# name of a type if possible, or the full type name otherwise
</summary>
</member>
<member name="M:Mono.CSharp.TypeManager.HasElementType(Mono.CSharp.TypeSpec)">
<summary>
This method is not implemented by MS runtime for dynamic types
</summary>
</member>
<member name="M:Mono.CSharp.TypeManager.VerifyUnmanaged(Mono.CSharp.ModuleContainer,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
<summary>
Utility function that can be used to probe whether a type
is managed or not.
</summary>
</member>
<member name="M:Mono.CSharp.TypeManager.IsInstantiationOfSameGenericType(Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
<summary>
Check whether `type' and `parent' are both instantiations of the same
generic type. Note that we do not check the type parameters here.
</summary>
</member>
<member name="T:Mono.CSharp.Return">
<summary>
Implements the return statement
</summary>
</member>
<member name="T:Mono.CSharp.Block">
<summary>
Block represents a C# block.
</summary>
<remarks>
This class is used in a number of places: either to represent
explicit blocks that the programmer places or implicit blocks.
Implicit blocks are used as labels or to introduce variable
declarations.
Top-level blocks derive from Block, and they are called ToplevelBlock
they contain extra information that is not necessary on normal blocks.
</remarks>
</member>
<member name="T:Mono.CSharp.ParameterBase">
<summary>
Abstract Base class for parameters of a method.
</summary>
</member>
<member name="T:Mono.CSharp.Location">
<summary>
Keeps track of the location in the program
</summary>
<remarks>
This uses a compact representation and a couple of auxiliary
structures to keep track of tokens to (file,line and column)
mappings. The usage of the bits is:
- 16 bits for "checkpoint" which is a mixed concept of
file and "line segment"
- 8 bits for line delta (offset) from the line segment
- 8 bits for column number.
http://lists.ximian.com/pipermail/mono-devel-list/2004-December/009508.html
</remarks>
</member>
<member name="P:Mono.CSharp.Location.IsNull">
<summary>
Whether the Location is Null
</summary>
</member>
<member name="M:Mono.CSharp.MethodData.DefineMethodBuilder(Mono.CSharp.TypeDefinition,System.String,Mono.CSharp.ParametersCompiled)">
<summary>
Create the MethodBuilder for the method
</summary>
</member>
<member name="M:Mono.CSharp.Namespace.#ctor(Mono.CSharp.Namespace,System.String)">
<summary>
Constructor Takes the current namespace and the
name. This is bootstrapped with parent == null
and name = ""
</summary>
</member>
<member name="P:Mono.CSharp.Namespace.Name">
<summary>
The qualified name of the current namespace
</summary>
</member>
<member name="P:Mono.CSharp.Namespace.Parent">
<summary>
The parent of this namespace, used by the parser to "Pop"
the current namespace declaration
</summary>
</member>
<member name="T:Mono.CSharp.ReturnParameter">
<summary>
Class for applying custom attributes on the return type
</summary>
</member>
<member name="P:Mono.CSharp.ReturnParameter.ValidAttributeTargets">
<summary>
Is never called
</summary>
</member>
<member name="T:Mono.CSharp.ParametersCompiled">
<summary>
Represents the methods parameters
</summary>
</member>
<member name="F:Mono.CSharp.PendingImplementation.container">
<summary>
The container for this PendingImplementation
</summary>
</member>
<member name="F:Mono.CSharp.PendingImplementation.pending_implementations">
<summary>
This is the array of TypeAndMethods that describes the pending implementations
(both interfaces and abstract methods in base class)
</summary>
</member>
<member name="M:Mono.CSharp.PendingImplementation.IsInterfaceMethod(Mono.CSharp.MemberName,Mono.CSharp.TypeSpec,Mono.CSharp.MethodData,Mono.CSharp.MethodSpec@,System.Boolean@)">
<summary>
Whether the specified method is an interface method implementation
</summary>
</member>
<member name="M:Mono.CSharp.PendingImplementation.InterfaceMethod(Mono.CSharp.MemberName,Mono.CSharp.TypeSpec,Mono.CSharp.MethodData,Mono.CSharp.PendingImplementation.Operation,Mono.CSharp.MethodSpec@,System.Boolean@)">
<remarks>
If a method in Type `t' (or null to look in all interfaces
and the base abstract class) with name `Name', return type `ret_type' and
arguments `args' implements an interface, this method will
return the MethodInfo that this method implements.
If `name' is null, we operate solely on the method's signature. This is for
instance used when implementing indexers.
The `Operation op' controls whether to lookup, clear the pending bit, or clear
all the methods with the given signature.
The `MethodInfo need_proxy' is used when we're implementing an interface's
indexer in a class. If the new indexer's IndexerName does not match the one
that was used in the interface, then we always need to create a proxy for it.
</remarks>
</member>
<member name="M:Mono.CSharp.PendingImplementation.DefineProxy(Mono.CSharp.TypeSpec,Mono.CSharp.MethodSpec,Mono.CSharp.MethodSpec)">
<summary>
C# allows this kind of scenarios:
interface I { void M (); }
class X { public void M (); }
class Y : X, I { }
For that case, we create an explicit implementation function
I.M in Y.
</summary>
</member>
<member name="M:Mono.CSharp.PendingImplementation.BaseImplements(Mono.CSharp.TypeSpec,Mono.CSharp.MethodSpec,Mono.CSharp.MethodSpec@)">
<summary>
This function tells whether one of our base classes implements
the given method (which turns out, it is valid to have an interface
implementation in a base
</summary>
</member>
<member name="M:Mono.CSharp.PendingImplementation.VerifyPendingMethods">
<summary>
Verifies that any pending abstract methods or interface methods
were implemented.
</summary>
</member>
<member name="T:Mono.CSharp.EventProperty">
<summary>
For case when event is declared like property (with add and remove accessors).
</summary>
</member>
<member name="T:Mono.CSharp.EventField">
<summary>
Event is declared like field.
</summary>
</member>
<member name="F:Mono.CSharp.Report.extra_information">
<summary>
List of symbols related to reported error/warning. You have to fill it before error/warning is reported.
</summary>
</member>
<member name="M:Mono.CSharp.Report.SymbolRelatedToPreviousError(Mono.CSharp.Location,System.String)">
<summary>
In most error cases is very useful to have information about symbol that caused the error.
Call this method before you call Report.Error when it makes sense.
</summary>
</member>
<member name="T:Mono.CSharp.WarningRegions">
<summary>
Handles #pragma warning
</summary>
</member>
<member name="T:Mono.CSharp.GotoDefault">
<summary>
`goto default' statement
</summary>
</member>
<member name="T:Mono.CSharp.GotoCase">
<summary>
`goto case' statement
</summary>
</member>
<member name="F:Mono.CSharp.Switch.SwitchType">
<summary>
The governing switch type
</summary>
</member>
<member name="T:Mono.CSharp.Foreach">
<summary>
Implementation of the foreach C# statement
</summary>
</member>
<member name="T:Mono.CSharp.SeekableStreamReader">
<summary>
This is an arbitrarily seekable StreamReader wrapper.
It uses a self-tuning buffer to cache the seekable data,
but if the seek is too far, it may read the underly
stream all over from the beginning.
</summary>
</member>
<member name="P:Mono.CSharp.SeekableStreamReader.Position">
<remarks>
This value corresponds to the current position in a stream of characters.
The StreamReader hides its manipulation of the underlying byte stream and all
character set/decoding issues. Thus, we cannot use this position to guess at
the corresponding position in the underlying byte stream even though there is
a correlation between them.
</remarks>
</member>
<member name="T:Mono.CSharp.CompletionResult">
<summary>
An exception used to terminate the compiler resolution phase and provide completions
</summary>
<remarks>
This is thrown when we want to return the completions or
terminate the completion process by AST nodes used in
the completion process.
</remarks>
</member>
<member name="M:Mono.CSharp.TypeSpecComparer.Unify.MayBecomeEqualGenericTypes(Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
<summary>
Check whether `a' and `b' may become equal generic types.
The algorithm to do that is a little bit complicated.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ICodeIssueProvider">
<summary>
The code issue provider gets a list of all code issues in a compilation unit.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.ICodeIssueProvider.GetIssues(ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext)">
<summary>
Gets all code issues inside a compilation unit.
</summary>
<param name='context'>
The refactoring context of the issues to get.
</param>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.GatherVisitorBase">
<summary>
A base class for writing issue provider visitor implementations.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.GatherVisitorBase.#ctor(ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext)">
<summary>
Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.GatherVisitorBase"/> class.
</summary>
<param name="ctx">
The refactoring context.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.GatherVisitorBase.GetIssues">
<summary>
Gets all the issues using the context root node as base.
</summary>
<returns>
The issues.
</returns>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.DocumentScript">
<summary>
Script implementation based on IDocument.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.Script">
<summary>
Class for creating change scripts.
'Original document' = document without the change script applied.
'Current document' = document with the change script (as far as it is already created) applies.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.GetCurrentOffset(System.Int32)">
<summary>
Given an offset in the original document (at the start of script execution),
returns the offset in the current document.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.GetCurrentOffset(ICSharpCode.NRefactory.TextLocation)">
<summary>
Given an offset in the original document (at the start of script execution),
returns the offset in the current document.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.CreateTrackedSegment(System.Int32,System.Int32)">
<summary>
Creates a tracked segment for the specified (offset,length)-segment.
Offset is interpreted to be an offset in the current document.
</summary>
<returns>
A segment that initially has the specified values, and updates
on every <see cref="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Replace(System.Int32,System.Int32,System.String)"/> call.
</returns>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Replace(System.Int32,System.Int32,System.String)">
<summary>
Replaces text.
</summary>
<param name="offset">The starting offset of the text to be replaced.</param>
<param name="length">The length of the text to be replaced.</param>
<param name="newText">The new text.</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Rename(ICSharpCode.NRefactory.TypeSystem.IEntity,System.String)">
<summary>
Renames the specified entity.
</summary>
<param name='entity'>
The Entity to rename
</param>
<param name='name'>
The new name, if null the user is prompted for a new name.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.RenameTypeParameter(ICSharpCode.NRefactory.TypeSystem.IType,System.String)">
<summary>
Renames the specified entity.
</summary>
<param name='type'>
The Entity to rename
</param>
<param name='name'>
The new name, if null the user is prompted for a new name.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Rename(ICSharpCode.NRefactory.TypeSystem.IVariable,System.String)">
<summary>
Renames the specified variable.
</summary>
<param name='variable'>
The Variable to rename
</param>
<param name='name'>
The new name, if null the user is prompted for a new name.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.CreateNewType(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.Refactoring.Script.NewTypeContext)">
<summary>
Creates a new file containing the type, namespace and correct usings.
(Note: Should take care of IDE specific things, file headers, add to project, correct name).
</summary>
<param name='newType'>
New type to be created.
</param>
<param name='context'>
The Context in which the new type should be created.
</param>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.Script.NewTypeContext.CurrentNamespace">
<summary>
The class should be placed in a new file to the current namespace.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.Script.NewTypeContext.UnitTests">
<summary>
The class should be placed in the unit tests. (not implemented atm.)
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.PatternHelper">
<summary>
Helper class for constructing pattern ASTs.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.PatternHelper.CommutativeOperator(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.CSharp.BinaryOperatorType,ICSharpCode.NRefactory.CSharp.Expression)">
<summary>
Produces a choice pattern for <c>expr1 op expr2</c> or <c>expr2 op expr1</c>.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringAstHelper">
<summary>
Helper methods for constructing ASTs for refactoring.
These helpers work with frozen ASTs, i.e. they clone input nodes.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringAstHelper.RemoveTarget(ICSharpCode.NRefactory.CSharp.MemberReferenceExpression)">
<summary>
Removes the target from a member reference while preserving the identifier and type arguments.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringAstHelper.RemoveTarget(ICSharpCode.NRefactory.CSharp.MemberType)">
<summary>
Removes the target from a member reference while preserving the identifier and type arguments.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.CreateDefiniteAssignmentAnalysis(ICSharpCode.NRefactory.CSharp.Statement)">
<summary>
Creates a new definite assignment analysis object with a given root statement.
</summary>
<returns>
The definite assignment analysis object.
</returns>
<param name='root'>
The root statement.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.TranslateString(System.String)">
<summary>
Translates the english input string to the context language.
</summary>
<returns>
The translated string.
</returns>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.GetService(System.Type)">
<summary>
Retrieves a service from the refactoring context.
If the service is not found in the <see cref="P:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.Services"/> container.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.UseExplicitTypes">
<summary>
Gets a value indicating if 'var' keyword should be used or explicit types.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.Services">
<summary>
Gets a service container used to associate services with this context.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder">
<summary>
Converts from type system to the C# AST.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
<summary>
Creates a new TypeSystemAstBuilder.
</summary>
<param name="resolver">
A resolver initialized for the position where the type will be inserted.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.#ctor">
<summary>
Creates a new TypeSystemAstBuilder.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.TypeMatches(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.ITypeDefinition,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
<summary>
Gets whether 'type' is the same as 'typeDef' parameterized with the given type arguments.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.AddTypeArguments(ICSharpCode.NRefactory.CSharp.AstType,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Int32,System.Int32)">
<summary>
Adds type arguments to the result type.
</summary>
<param name="result">The result AST node (a SimpleType or MemberType)</param>
<param name="typeArguments">The list of type arguments</param>
<param name="startIndex">Index of first type argument to add</param>
<param name="endIndex">Index after last type argument to add</param>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.AddAnnotations">
<summary>
Specifies whether the ast builder should add annotations to type references.
The default value is <c>false</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowAccessibility">
<summary>
Controls the accessibility modifiers are shown.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowModifiers">
<summary>
Controls the non-accessibility modifiers are shown.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowBaseTypes">
<summary>
Controls whether base type references are shown.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowTypeParameters">
<summary>
Controls whether type parameter declarations are shown.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowTypeParameterConstraints">
<summary>
Controls whether contraints on type parameter declarations are shown.
Has no effect if ShowTypeParameters is false.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowParameterNames">
<summary>
Controls whether the names of parameters are shown.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowConstantValues">
<summary>
Controls whether to show default values of optional parameters, and the values of constant fields.
The default value is <c>true</c>.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.AlwaysUseShortTypeNames">
<summary>
Controls whether to use fully-qualified type names or short type names.
The default value is <c>false</c>.
</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 a 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.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.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.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.CompilationUnit,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpParsedFile)">
<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="compilationUnit">The compilation unit corresponding to the specified parsed file.</param>
<param name="parsedFile">
Optional: Result of the <see cref="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor"/> for the file being resolved.
<para>
This is used for setting up the context on the resolver. The parsed file must be registered in the compilation.
</para>
<para>
When a parsedFile 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 parsedFile 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.CSharpParsedFile)">
<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: outside the root node).</param>
<param name="rootNode">The root node of the resolved tree.</param>
<param name="parsedFile">
Optional: Result of the <see cref="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor"/> for the file being resolved.
<para>
This is used for setting up the context on the resolver. The parsed file must be registered in the compilation.
</para>
<para>
When a parsedFile 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 parsedFile 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.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 being 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="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.ParsedFile">
<summary>
Gets the parsed file used by this CSharpAstResolver.
Can return null.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult">
<summary>
Represents the result of a method invocation.
</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="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.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="T:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution">
<summary>
C# overload resolution (C# 4.0 spec: §7.5).
</summary>
</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).</param>
<returns>True if the constraints are satisfied; false otherwise.</returns>
</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="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.CreateResolveResult(ICSharpCode.NRefactory.Semantics.ResolveResult,System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult})">
<summary>
Creates a ResolveResult representing the result of overload resolution.
</summary>
<param name="targetResolveResult">
The target expression of the call. May be <c>null</c> for static methods/constructors.
</param>
<param name="initializerStatements">
Statements for Objects/Collections initializer.
<see cref="F:ICSharpCode.NRefactory.Semantics.InvocationResolveResult.InitializerStatements"/>
</param>
</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.Arguments">
<summary>
Gets the arguments for which this OverloadResolution instance was created.
</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="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="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="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver">
<summary>
Contains the main resolver logic.
</summary>
<remarks>
This class is thread-safe.
</remarks>
</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="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithIsWithinLambdaExpression(System.Boolean)">
<summary>
Sets whether the resolver is currently within a lambda expression.
</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="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="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="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="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 &(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.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 specialized (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">
<summary>
Gets all extension methods available in the current using scope.
This list includes unaccessible
</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.ResolveArrayCreation(ICSharpCode.NRefactory.TypeSystem.IType,System.Int32,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="dimensions">
The number of array dimensions.
</param>
<param name="sizeArguments">
The size arguments. May be null if no explicit size was given.
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="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="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsWithinLambdaExpression">
<summary>
Gets 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="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="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentTypeDefinition">
<summary>
Gets the current type definition.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.LocalVariables">
<summary>
Gets all currently visible local variables and lambda parameters.
</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="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 compilation unit 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.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="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.TypeSystem.CSharpParsedFile,ICSharpCode.NRefactory.CSharp.CompilationUnit,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="parsedFile">The type system representation of the file being searched.</param>
<param name="compilationUnit">The compilation unit 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.CSharpParsedFile,ICSharpCode.NRefactory.CSharp.CompilationUnit,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="parsedFile">The type system representation of the file being searched.</param>
<param name="compilationUnit">The compilation unit 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.CSharpParsedFile,ICSharpCode.NRefactory.CSharp.CompilationUnit,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="parsedFile">The type system representation of the file being searched.</param>
<param name="compilationUnit">The compilation unit 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.CSharpParsedFile,ICSharpCode.NRefactory.CSharp.CompilationUnit,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="parsedFile">The type system representation of the file being searched.</param>
<param name="compilationUnit">The compilation unit 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="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><param></c> and <c><paramref></c> tags.
TODO: implement this feature.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope">
<summary>
Represents a scope in which references 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="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="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.
</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>
</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.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="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.Parameters">
<summary>
Gets the list of parameters.
</summary>
</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.TypeSystem.IType)">
<summary>
Gets whether access to protected instance members of the target type is possible.
</summary>
</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 accessibe even if false is passed for this parameter.
</param>
</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.TypeSystem.IType)">
<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.MethodGroupResolveResult">
<summary>
Represents a group of methods.
</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.
</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="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="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="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>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.Inaccessible">
<summary>
The member is not accessible.
</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.CSharpParsedFile)">
<summary>
Creates a new ResolveVisitor instance.
</summary>
<param name="resolver">
The CSharpResolver, describing the initial resolve context.
If you visit a whole CompilationUnit with the resolve visitor, you can simply pass
<c>new CSharpResolver(typeResolveContext)</c> without setting up the context.
If you only visit a subtree, you need to pass a CSharpResolver initialized to the context for that subtree.
</param>
<param name="parsedFile">
Result of the <see cref="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor"/> for the file being passed. This is used for setting up the context on the resolver.
You may pass <c>null</c> if you are only visiting a part of a method body and have already set up the context in the <paramref name="resolver"/>.
</param>
</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(compilationUnit); 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.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.UnpackTask(ICSharpCode.NRefactory.TypeSystem.IType)">
<summary>
Gets the T in Task<T>.
Returns void for non-generic Task.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.IsTask(ICSharpCode.NRefactory.TypeSystem.IType)">
<summary>
Gets whether the specified type is Task or Task<T>.
</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="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="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="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="P:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.Algorithm">
<summary>
Gets/Sets the type inference algorithm used.
</summary>
</member>
<!-- Badly formed XML comment ignored for member "M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateLiteralCompletionData(System.String,System.String,System.String)" -->
<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.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.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="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.ResolveType(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
<summary>
Returns the type that is referenced; or <see cref="F:ICSharpCode.NRefactory.TypeSystem.SpecialType.UnknownType"/> if the type isn't found.
</summary>
</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.CSharpDocumentationComment">
<summary>
DocumentationComment with C# cref lookup.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpParsedFile">
<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.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="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.CSharpParsedFile,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="parsedFile">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="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="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.Completion.CSharpCompletionEngineBase">
<summary>
Acts as a common base between code completion and parameter completion.
</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.Refactoring.CodeIssue">
<summary>
A code issue marks a region of text with an issue and can provide solution actions for this issue.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.#ctor(System.String,ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction})">
<summary>
Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue"/> class.
</summary>
<param name="description">
The desription of the issue.
</param>
<param name="start">
The issue start location.
</param>
<param name="end">
the issue end location.
</param>
<param name="actions">
A list of potential solutions for the issue.
</param>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.#ctor(System.String,ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction)">
<summary>
Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue"/> class.
</summary>
<param name="description">
The desription of the issue.
</param>
<param name="start">
The issue start location.
</param>
<param name="end">
the issue end location.
</param>
<param name="action">
A potential solution for the issue.
</param>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.Desription">
<summary>
Gets the desription of the issue.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.Start">
<summary>
Gets the issue start location.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.End">
<summary>
Gets the issue end location.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.Actions">
<summary>
Gets a list of potential solutions for the issue.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction">
<summary>
A code action provides a code transformation with a description.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction.#ctor(System.String,System.Action{ICSharpCode.NRefactory.CSharp.Refactoring.Script})">
<summary>
Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction"/> class.
</summary>
<param name="description">
The description.
</param>
<param name="action">
The code transformation.
</param>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction.Description">
<summary>
Gets the description.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction.Run">
<summary>
Gets the code transformation.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Severity">
<summary>
The severity influences how the task bar reacts on found issues.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Severity.None">
<summary>
None means that the task bar doesn't show the issue.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Severity.Error">
<summary>
Errors are shown in red and that the task bar is in error state if 1 error is found.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Severity.Warning">
<summary>
Warnings are shown in yellow and set the task bar to warning state (if no error is found).
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Severity.Suggestion">
<summary>
Suggestions are shown in green and doesn't influence the task bar state
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Severity.Hint">
<summary>
Hints are shown in blue and doesn't influence the task bar state
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.IssueMarker">
<summary>
The issue marker is used to set how an issue should be marked inside the text editor.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.IssueMarker.None">
<summary>
The issue is not shown inside the text editor. (But in the task bar)
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.IssueMarker.Underline">
<summary>
The region is marked as underline in the severity color.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.IssueMarker.GrayOut">
<summary>
The text is grayed out.
</summary>
</member>
<!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.Refactoring.ConditionalToNullCoalescingIssue" -->
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.NotImplementedExceptionIssue">
<summary>
This inspector just shows that there is a not implemented exception. It doesn't offer a fix.
Should only be shown in overview bar, no underlining.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantInternalIssue">
<summary>
Finds redundant internal modifiers.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantNamespaceUsageIssue">
<summary>
Finds redundant namespace usages.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantPrivateIssue">
<summary>
Finds redundant internal modifiers.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantThisIssue">
<summary>
Finds redundant namespace usages.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantUsingIssue">
<summary>
Finds redundant using declarations.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantUsingIssue.NamespacesToKeep">
<summary>
The list of namespaces that should be kept even if they are not being used.
Used in SharpDevelop to always keep the "System" namespace around.
</summary>
</member>
<!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.Refactoring.StringIsNullOrEmptyIssue" -->
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.UseVarKeywordIssue">
<summary>
Checks for places where the 'var' keyword can be used. Note that the action is actually done with a context
action.
</summary>
</member>
<!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.Refactoring.IntroduceFormatItemAction" -->
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertHexToDecAction">
<summary>
Convert a hex numer to dec. For example: 0x10 -> 16
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertForeachToForAction">
<summary>
Converts a foreach loop to for.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertDecToHexAction">
<summary>
Convert a dec numer to hex. For example: 16 -> 0x10
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.CheckIfParameterIsNullAction">
<summary>
Creates a 'if (param == null) throw new System.ArgumentNullException ();' contruct for a parameter.
</summary>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.SpecializedCodeAction`1">
<summary>
A specialized code action creates a code action assoziated with one special type of ast nodes.
</summary>
</member>
<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.SpecializedCodeAction`1.GetAction(ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringContext,`0)">
<summary>
Gets the action for the specified ast node.
</summary>
<returns>
The code action. May return <c>null</c>, if no action can be provided.
</returns>
<param name='context'>
The refactoring conext.
</param>
<param name='node'>
The AstNode it's ensured that the node is always != null, if called.
</param>
</member>
<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.AddAnotherAccessorAction">
<summary>
Add another accessor to a property declaration that has only one.
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.PascalCase">
<summary>
PascalCase
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.CamelCase">
<summary>
camelCase
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.AllUpper">
<summary>
ALLUPPER
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.AllLower">
<summary>
alllower
</summary>
</member>
<member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.FirstUpper">
<summary>
Firstupper
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.RequiredPrefixes">
<summary>
If set, identifiers are required to be prefixed with one of these values.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.AllowedPrefixes">
<summary>
If set, identifiers are allowed to be prefixed with one of these values.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.RequiredSuffixes">
<summary>
If set, identifiers are required to be suffixed with one of these values.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.ForbiddenPrefixes">
<summary>
If set, identifiers cannot be prefixed by any of these values.
</summary>
</member>
<!-- Badly formed XML comment ignored for member "P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.ForbiddenSuffixes" -->
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.AffectedEntity">
<summary>
Gets or sets the affected entity.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.VisibilityMask">
<summary>
Gets or sets the modifiers mask
</summary>
</member>
<!-- Badly formed XML comment ignored for member "P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.NamingStyle" -->
<member name="T:ICSharpCode.NRefactory.CSharp.TextEditorOptions">
<summary>
The text editor options class holds basic information about the text editor settings that influences code generation and formatting beside
the CSharpFormattingOptions.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.TabsToSpaces">
<summary>
Gets or sets a value indicating if tabs need to be replaced by spaces. If that is true, all indenting will be done with spaces only,
otherwise the indenting will start with tabs.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.TabSize">
<summary>
Gets or sets the size of the tab chacter as spaces.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.IndentSize">
<summary>
Gets or sets the size of a single indent as spaces.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.ContinuationIndent">
<summary>
Gets or sets the continuation indent. A continuation indent is the indent that will be put after an embedded statement that is no block.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.LabelIndent">
<summary>
Gets or sets the label indent. A label indent is the indent that will be put before an label.
(Note: it may be negative -IndentSize would cause that labels are unindented)
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.EolMarker">
<summary>
Gets or sets the eol marker.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.IndentBlankLines">
<summary>
If true blank lines will be indented up to the indent level, otherwise blank lines will have the length 0.
</summary>
</member>
<member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.WrapLineLength">
<summary>
Gets or sets the length of the desired line length. The formatting engine will wrap at wrap points set to Wrapping.WrapIfTooLong if the line length is too long.
0 means do not wrap.
</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>
</members>
</doc>
Submit an article or tip