<?xml version="1.0"?>

<doc>

<assembly>

<name>ICSharpCode.NRefactory.CSharp</name>

</assembly>

<members>

<member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ICodeIssueProvider">

<summary>

The code issue provider gets a list of all code issues in a syntax tree.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.ICodeIssueProvider.GetIssues(ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext)">

<summary>

Gets all code issues inside a syntax tree.

</summary>

<param name='context'>

The refactoring context of the issues to get.

</param>

</member>

<member name="T:ICSharpCode.NRefactory.CSharp.GatherVisitorBase`1">

<summary>

A base class for writing issue provider visitor implementations.

</summary>

</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="F:ICSharpCode.NRefactory.CSharp.GatherVisitorBase`1.IssueProvider">

<summary>

The issue provider. May be <c>null</c> if none was specified.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.GatherVisitorBase`1.#ctor(ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext,`0)">

<summary>

Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.GatherVisitorBase`1"/> class.

</summary>

<param name="ctx">

The refactoring context.

</param>

<param name="issueProvider">

The issue provider.

</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.GatherVisitorBase`1.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.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.TextNode">

<summary>

A text node contains text without syntactic or semantic information.

(non parseable part of a text)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetRegion">

<summary>

Gets the region from StartLocation to EndLocation for this node.

The file name of the region is set based on the parent SyntaxTree's file name.

If this node is not connected to a whole compilation, the file name will be null.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetChildByRole``1(ICSharpCode.NRefactory.Role{``0})">

<summary>

Gets the first child with the specified role.

Returns the role's null object if the child is not found.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.AddChildUnsafe(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Role)">

<summary>

Adds a child without performing any safety checks.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Remove">

<summary>

Removes this node from its parent.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.ReplaceWith(ICSharpCode.NRefactory.CSharp.AstNode)">

<summary>

Replaces this node with the new node.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Clone">

<summary>

Clones the whole subtree starting at this AST node.

</summary>

<remarks>Annotations are copied over to the new nodes; and any annotations implementing ICloneable will be cloned.</remarks>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNextNode(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">

<summary>

Gets the next node which fullfills a given predicate

</summary>

<returns>The next node.</returns>

<param name="pred">The predicate.</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetPrevNode(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">

<summary>

Gets the previous node which fullfills a given predicate

</summary>

<returns>The next node.</returns>

<param name="pred">The predicate.</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNextSibling(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">

<summary>

Gets the next sibling which fullfills a given predicate

</summary>

<returns>The next node.</returns>

<param name="pred">The predicate.</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetPrevSibling(System.Func{ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean})">

<summary>

Gets the next sibling which fullfills a given predicate

</summary>

<returns>The next node.</returns>

<param name="pred">The predicate.</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt(System.Int32,System.Int32,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">

<summary>

Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End exclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt(ICSharpCode.NRefactory.TextLocation,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">

<summary>

Gets the node specified by pred at location. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End exclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt``1(System.Int32,System.Int32)">

<summary>

Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End exclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt``1(ICSharpCode.NRefactory.TextLocation)">

<summary>

Gets the node specified by T at location. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End exclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt(System.Int32,System.Int32,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">

<summary>

Gets the node specified by pred at the location line, column. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End inclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt(ICSharpCode.NRefactory.TextLocation,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">

<summary>

Gets the node specified by pred at location. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End inclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt``1(System.Int32,System.Int32)">

<summary>

Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End inclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt``1(ICSharpCode.NRefactory.TextLocation)">

<summary>

Gets the node specified by T at location. This is useful for getting a specific node from the tree. For example searching

the current method declaration.

(End inclusive)

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeContaining(ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation)">

<summary>

Gets the node that fully contains the range from startLocation to endLocation.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.ToString(ICSharpCode.NRefactory.CSharp.CSharpFormattingOptions)">

<summary>

Gets the node as formatted C# output.

</summary>

<param name='formattingOptions'>

Formatting options.

</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Contains(System.Int32,System.Int32)">

<summary>

Returns true, if the given coordinates (line, column) are in the node.

</summary>

<returns>

True, if the given coordinates are between StartLocation and EndLocation (exclusive); otherwise, false.

</returns>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Contains(ICSharpCode.NRefactory.TextLocation)">

<summary>

Returns true, if the given coordinates are in the node.

</summary>

<returns>

True, if location is between StartLocation and EndLocation (exclusive); otherwise, false.

</returns>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.IsInside(System.Int32,System.Int32)">

<summary>

Returns true, if the given coordinates (line, column) are in the node.

</summary>

<returns>

True, if the given coordinates are between StartLocation and EndLocation (inclusive); otherwise, false.

</returns>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.AstNode.IsInside(ICSharpCode.NRefactory.TextLocation)">

<summary>

Returns true, if the given coordinates are in the node.

</summary>

<returns>

True, if location is between StartLocation and EndLocation (inclusive); otherwise, false.

</returns>

</member>

<member name="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="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.CreateReachabilityAnalysis(ICSharpCode.NRefactory.CSharp.Statement)">

<summary>

Creates a new reachability analysis object with a given statement.

</summary>

<param name="statement">

The statement to start the analysis.

</param>

<returns>

The reachability analysis object.

</returns>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.ParseFormatString(System.String)">

<summary>

Parses a composite format string.

</summary>

<returns>

The format string parsing result.

</returns>

</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.Completion.CSharpCompletionEngineBase">

<summary>

Acts as a common base between code completion and parameter completion.

</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 syntax tree for those nodes.

However, scanning in the ResolveVisitor is expensive (e.g. any lambda that is scanned must be resolved),

so it makes sense to detect when a whole subtree is scan-only, and skip that tree instead.

The DetectSkippableNodesNavigator performs this job by running the input IResolveVisitorNavigator

over the whole AST, and detecting subtrees that are scan-only, and replaces them with Skip.

</summary>

</member>

<member name="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="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.DynamicMemberResolveResult">

<summary>

Represents the result of an access to a member of a dynamic object.

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult.Target">

<summary>

Target of the member access (a dynamic object).

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult.Member">

<summary>

Name of the accessed member.

</summary>

</member>

<member name="T:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult">

<summary>

Represents the result of an await expression.

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.GetAwaiterInvocation">

<summary>

The method representing the GetAwaiter() call. Can be an <see cref="T:ICSharpCode.NRefactory.Semantics.InvocationResolveResult"/> or a <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult"/>.

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.AwaiterType">

<summary>

Awaiter type. Will not be null (but can be UnknownType).

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.IsCompletedProperty">

<summary>

Property representing the IsCompleted property on the awaiter type. Can be null if the awaiter type or the property was not found, or when awaiting a dynamic expression.

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.OnCompletedMethod">

<summary>

Method representing the OnCompleted method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.

This can also refer to an UnsafeOnCompleted method, if the awaiter type implements <c>System.Runtime.CompilerServices.ICriticalNotifyCompletion</c>.

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.GetResultMethod">

<summary>

Method representing the GetResult method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.

</summary>

</member>

<member name="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="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.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="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.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.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="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="T:Mono.CSharp.Invocation">

<summary>

Invocation of methods or delegates.

</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.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.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.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="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.TypeExpr">

<summary>

Expression that evaluates to a type

</summary>

</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.Assign">

<summary>

The Assign node takes care of assigning the value of source into

the expression represented by target.

</summary>

</member>

<member name="T:ICSharpCode.NRefactory.CSharp.LockStatement">

<summary>

lock (Expression) EmbeddedStatement;

</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.LambdaExpression">

<summary>

[async] 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.IndexerExpression">

<summary>

Target[Arguments]

</summary>

</member>

<member name="T:ICSharpCode.NRefactory.CSharp.AnonymousTypeCreateExpression">

<summary>

new { [ExpressionList] }

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.GetTypes(System.Boolean)">

<summary>

Gets all defined types in this syntax tree.

</summary>

<returns>

A list containing <see cref="T:ICSharpCode.NRefactory.CSharp.TypeDeclaration"/> or <see cref="T:ICSharpCode.NRefactory.CSharp.DelegateDeclaration"/> nodes.

</returns>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem">

<summary>

Converts this syntax tree into a parsed file that can be stored in the type system.

</summary>

</member>

<member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.FileName">

<summary>

Gets/Sets the file name of this syntax tree.

</summary>

</member>

<member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.ConditionalSymbols">

<summary>

Gets the conditional symbols used to parse the source file. Note that this list contains

the conditional symbols at the start of the first token in the file - including the ones defined

in the source file.

</summary>

</member>

<member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.TopExpression">

<summary>

Gets the expression that was on top of the parse stack.

This is the only way to get an expression that isn't part of a statment.

(eg. when an error follows an expression).

This is used for code completion to 'get the expression before a token - like ., &lt;, ('.

</summary>

</member>

<member name="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="F:ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngine.AutoCompleteEmptyMatchOnCurlyBracket">

<summary>

The auto complete empty match on curly bracket. (only taken into account when AutoCompleteEmptyMatch is true )

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngine.GetImportCompletionData(System.Int32)">

<summary>

Gets the types that needs to be imported via using or full type name.

</summary>

</member>

<member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile">

<summary>

Represents a file that was parsed and converted for the type system.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateMemberCompletionData(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IEntity)">

<summary>

Creates the member completion data.

Form: Type.Member

Used for generating enum members Foo.A, Foo.B where the enum 'Foo' is valid.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateLiteralCompletionData(System.String,System.String,System.String)">

<summary>

Creates a generic completion data.

</summary>

<param name='title'>

The title of the completion data

</param>

<param name='description'>

The description of the literal.

</param>

<param name='insertText'>

The insert text. If null, title is taken.

</param>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateImportCompletionData(ICSharpCode.NRefactory.TypeSystem.IType,System.Boolean)">

<summary>

Creates a completion data that adds the required using for the created type.

</summary>

<param name="type">The type to import</param>

<param name="useFullName">If set to true the full name of the type needs to be used.</param>

</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="T:ICSharpCode.NRefactory.CSharp.IAstVisitor`1">

<summary>

AST visitor.

</summary>

</member>

<member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.currentQueryResult">

<summary>Resolve result of the current LINQ query.</summary>

<remarks>We do not have to put this into the stored state (resolver) because

query expressions are always resolved in a single operation.</remarks>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">

<summary>

Creates a new ResolveVisitor instance.

</summary>

</member>

<member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ResetContext(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,System.Action)">

<summary>

Resets the visitor to the stored position, runs the action, and then reverts the visitor to the previous position.

</summary>

</member>