Microsoft.CodeAnalysis.VisualBasic.Workspaces
Return the classification type associated with this token.
The token to be classified.
The classification type for the token
Given a syntax token determines a text span delimited by the closest applicable sequence points
encompassing the token.
If the span exists it Is possible To place a breakpoint at the given position.
A visitor that determines if the targetToken passed in the constructor can be considered
the end of the visited statement. Tokens in the token stream of the file after
targetToken are ignored. This means that in some cases, say "Throw" vs. "Throw x" there
is more than one keyword that could terminate the statement.
We need to check for EOL trivia not preceded by LineContinuation trivia.
This is slightly complicated since we need to get TrailingTrivia from missing tokens
and then get LeadingTrivia for the next non-missing token
The specified position is where we can declare some .NET type, such as classes, structures, etc.
The specified position is where a keyword can go like "Sub", "Function", etc. in a classes, structures, and modules
The specified position is where a keyword can go like "Sub", "Function" in an interface
The specified position is where we can declare some .NET type, such as classes, structures, etc.
The specified position is where I could start a statement in a place where exactly one
statement could exist.
The specified position is where I could start a statement in a place where one or more
statements could exist.
The specified position is immediately following a statement of one of the given kinds.
Given a syntax node, this returns the token that is the "end" token that ends this
expression.
The expression to get the last token of.
The last token, or SyntaxKind.None if the last token is missing.
Helper structure to store some context about a position for keyword completion
True if position is after a colon, or an
EOL that was not preceded by an explicit line continuation
True if position is definitely the beginning of a new statement (after a colon
or two line breaks).
Dim q = From a In args
$1
$2
$1 may continue the previous statement, but $2 definitely starts a
new statement since there are two line breaks before it.
The specified position is immediately following a statement of one of the given kinds.
Returns a map which maps from a DirectiveTriviaSyntax to it's corresponding start/end directive.
Directives like #ElseIf which exist in the middle of a start/end pair are not included.
Maps a #If/#ElseIf/#Else/#EndIf directive to its list of matching #If/#ElseIf/#Else/#End directives.
Given a starting or ending directive, return the matching directive, if it exists. For directives that live
the "middle" of a start/end pair, such as #ElseIf or #Else, this method will throw.
Given a conditional directive (#If, #ElseIf, #Else, or #End If), returns a IEnumerable of all directives in
the set.
Decompose a name or member access expression into its component parts.
The name or member access expression.
The qualifier (or left-hand-side) of the name expression. This may be null if there is no qualifier.
The name of the expression.
The number of generic type parameters.
Checks if the SyntaxNode is a name of a namespace declaration. To be a namespace name, the syntax
must be parented by an namespace declaration and the node itself must be equal to the declaration's Name
property.
Returns the predefined keyword kind for a given special type.
The specialtype of this type.
The keyword kind for a given special type, or SyntaxKind.None if the type name is not a predefined type.
Determines whether the given IMethodSymbol can be used as an aggregate function
in a Group..By..Into or an Aggregate..Into clause.
Given an expression node, tries to generate an appropriate name that can be used for
that expression.
Determine if the given array contains the given kind.
Array to search
Sought value
True if contains the value .
PERF: Not using Array.IndexOf here because it results in a call to IndexOf on the default EqualityComparer for SyntaxKind. The default comparer for SyntaxKind is
the ObjectEqualityComparer which results in boxing allocations.
Locate the given in an array starting at the given index.
Array to search
Sought value
Starting index
The index of the first occurrence of in .
PERF: Not using Array.IndexOf here because it results in a call to IndexOf on the default EqualityComparer for SyntaxKind. The default comparer for SyntaxKind is
the ObjectEqualityComparer which results in boxing allocations.
Breaks up the list of provided nodes, based on how they are
interspersed with pp directives, into groups. Within these groups
nodes can be moved around safely, without breaking any pp
constructs.
Returns true if the passed in node contains an interleaved pp
directive.
i.e. The following returns false:
void Foo() {
#if true
#endif
}
#if true
void Foo() {
}
#endif
but these return true:
#if true
void Foo() {
#endif
}
void Foo() {
#if true
}
#endif
#if true
void Foo() {
#else
}
#endif
i.e. the method returns true if it contains a PP directive that
belongs to a grouping constructs (like #if/#endif or
#region/#endregion), but the grouping construct isn't entirely c
contained within the span of the node.
Returns true if this is a block that can contain multiple executable statements. i.e.
this node is the VB equivalent of a BlockSyntax in C#.
If the position is inside of token, return that token; otherwise, return the token to right.
If the position is inside of token, return that token; otherwise, return the token to left.
Returns child node or token that contains given position.
This is a copy of that also returns the index of the child node.
Look inside a trivia list for a skipped token that contains the given position.
Look inside a trivia list for a skipped token that contains the given position.
get skipped tokens from the trivia list
Returns true if is a given token is a child token of of a certain type of parent node.
The type of the parent node.
The token that we are testing.
A function that, when given the parent node, returns the child token we are interested in.
Returns true if is a given token is a separator token in a given parent list.
The type of the parent node containing the separated list.
The token that we are testing.
A function that, when given the parent node, returns the separated list.
Determines whether the given SyntaxToken is the first token on a line
Finds the token being touched by this position. Unlike the normal FindTrivia helper, this helper will prefer
trivia to the left rather than the right if the position is on the border.
The syntaxTree to search.
The position to find trivia.
If the position is inside of token, return that token; otherwise, return the token to right.
If the position is inside of token, return that token; otherwise, return the token to left.
check whether given token is the last token of a statement that ends with end of line trivia or an elastic trivia
check whether given token is the last token of a statement by walking up the spine
this holds onto changes made by formatting engine.
currently it only has an ability to apply those changes to buffer. but it could be expanded to
support other cases as well such as tree or etc.
trivia factory.
it will cache some commonly used trivia to reduce memory footprint and heap allocation
represents a general trivia between two tokens. slightly more expensive than others since it
needs to calculate stuff unlike other cases
represents a general trivia between two tokens. slightly more expensive than others since it
needs to calculate stuff unlike other cases
Get the declaring syntax node for a Symbol. Unlike the DeclaringSyntaxReferences property,
this function always returns a block syntax, if there is one.
If "node" is the begin statement of a declaration block, return that block, otherwise
return node.
Represents a syntax reference that was passed a null
reference to a node. In this case, we just hold onto the
weak tree reference and throw if any invalid properties
are accessed.
Represents a syntax reference that doesn't actually hold onto the
referenced node. Instead, enough data is held onto so that the node
can be recovered and returned if necessary.
Represents a syntax reference that doesn't actually hold onto the referenced node.
Instead, enough data is held onto so that the node can be recovered and returned if
necessary.
Represents a syntax tree that only has a weak reference to its
underlying data. This way it can be passed around without forcing
the underlying full tree to stay alive. Think of it more as a
key that can be used to identify a tree rather than the tree itself.
In MemberAccessExpression Contexts, filter out event symbols, except inside AddRemoveHandler Statements
Also, filter out any implicitly declared members generated by event declaration or property declaration
Gets the top most enclosing statement as target to call MakeExplicit on.
It's either the enclosing statement, or if this statement is inside of a lambda expression, the enclosing
statement of this lambda.
The token to get the complexification target for.
Gets the semantic model for the given node.
If the node belongs to the syntax tree of the original semantic model, then returns originalSemanticModel.
Otherwise, returns a speculative model.
The assumption for the later case is that span start position of the given node in it's syntax tree is same as
the span start of the original node in the original syntax tree.
Computes a list of nodes and tokens that need to be reduced in the given syntax root.
A helper class that is constructed giving a set of modifiers. It takes these modifiers, and
breaks them down into separate categories, as well as determines what type of declaration is
being forced if certain modifiers are present.
Helper class to analyze the semantic effects of a speculated syntax node replacement on the parenting nodes.
Given an expression node from a syntax tree and a new expression from a different syntax tree,
it replaces the expression with the new expression to create a speculated syntax tree.
It uses the original tree's semantic model to create a speculative semantic model and verifies that
the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
Creates a semantic analyzer for speculative syntax replacement.
Original expression to be replaced.
New expession to replace the orginal expression.
Semantic model of node's syntax tree.
Cancellation token.
True if semantic analysis should be skipped for the replaced node and performed starting from parent of the original and replaced nodes.
This could be the case when custom verifications are required to be done by the caller or
semantics of the replaced expression are different from the original expression.
True if semantic analysis should fail when any of the invocation expression ancestors of in original code has overload resolution failures.
Determines whether performing the syntax replacement in one of the sibling nodes of the given lambda expressions will change the lambda binding semantics.
This is done by first determining the lambda parameters whose type differs in the replaced lambda node.
For each of these parameters, we find the descendant identifier name nodes in the lambda body and check if semantics of any of the parenting nodes of these
identifier nodes have changed in the replaced lambda.
A strongly-typed resource class, for looking up localized strings, etc.
Returns the cached ResourceManager instance used by this class.
Overrides the current thread's CurrentUICulture property for all
resource lookups using this strongly typed resource class.
Looks up a localized string similar to Associates an event with an event handler, delegate or lambda expression at run time..
Looks up a localized string similar to Only attributes, expressions or statements can be made explicit.
Looks up a localized string similar to <condition>.
Looks up a localized string similar to Converts an expression to the {0} data type..
Looks up a localized string similar to Evaluated and returned if <condition> evaluates to False..
Looks up a localized string similar to Evaluated and returned if <condition> evaluates to True..
Looks up a localized string similar to <event>.
Looks up a localized string similar to The event handler to associate with the event. This may take the form of { AddressOf <eventHandler> | <delegate> | <lambdaExpression> }..
Looks up a localized string similar to The event handler to disassociate from the event. This may take the form of { AddressOf <eventHandler> | <delegate> }..
Looks up a localized string similar to The event to associate an event handler, delegate or lambda expression with..
Looks up a localized string similar to The event to disassociate an event handler or delegate from..
Looks up a localized string similar to <expression>.
Looks up a localized string similar to If <expression> evaluates to a reference or Nullable value that is not Nothing, the function returns that value. Otherwise, it calculates and returns <expressionIfNothing>..
Looks up a localized string similar to <expressionIfFalse>.
Looks up a localized string similar to <expressionIfNothing>.
Looks up a localized string similar to <expressionIfTrue>.
Looks up a localized string similar to The expression to be evaluated and converted..
Looks up a localized string similar to The expression to evaluate..
Looks up a localized string similar to <handler>.
Looks up a localized string similar to If <condition> returns True, the function calculates and returns <expressionIfTrue>. Otherwise, it returns <expressionIfFalse>..
Looks up a localized string similar to Introduces a type conversion operation that does not throw an exception. If an attempted conversion fails, TryCast returns Nothing, which your program can test for..
Looks up a localized string similar to Introduces a type conversion operation similar to CType. The difference is that CType succeeds as long as there is a valid conversion, whereas DirectCast requires that one type inherit from or implement the other type..
Looks up a localized string similar to <length>.
Looks up a localized string similar to Produces a string for the name of the specified type or member..
Looks up a localized string similar to The name of the string variable to modify..
Looks up a localized string similar to The name of the data type to which the value of expression will be converted..
Looks up a localized string similar to Namespace can not be added in this destination..
Looks up a localized string similar to {0}.
Looks up a localized string similar to Node does not descend from root..
Looks up a localized string similar to Node not in parent's child list.
Looks up a localized string similar to The number of characters to replace. If omitted, the length of <stringExpression> is used..
Looks up a localized string similar to The one-based character position in the string where the replacement of text begins..
Looks up a localized string similar to Removes the association between an event and an event handler or delegate at run time..
Looks up a localized string similar to Replaces a specified number of characters in a String variable with characters from another string..
Looks up a localized string similar to Returned if it evaluates to a reference or nullable type that is not Nothing..
Looks up a localized string similar to Evaluated and returned if <expression> evaluates to Nothing..
Looks up a localized string similar to Returns the result of explicitly converting an expression to a specified data type..
Looks up a localized string similar to Returns a System.Type object for the specified type name..
Looks up a localized string similar to Returns the System.Xml.Linq.XNamespace object corresponding to the specified XML namespace prefix..
Looks up a localized string similar to <startIndex>.
Looks up a localized string similar to <stringExpression>.
Looks up a localized string similar to <stringName>.
Looks up a localized string similar to Trivia is not associated with token.
Looks up a localized string similar to <typeName>.
Looks up a localized string similar to <typeOrMember>.
Looks up a localized string similar to The type of member to return the name of..
Looks up a localized string similar to The type name to return a System.Type object for..
Looks up a localized string similar to <xmlNamespacePrefix>.
Looks up a localized string similar to The XML namespace prefix to return a System.Xml.Linq.XNamespace object for. If this is omitted, the object for the default XML namespace is returned..
Rewrite "EndIf" to "End If" for an EndIfStatementSyntax/EndIfDirectiveSyntax node.
Syntax node for the EndIfStatementSyntax or EndIfDirectiveSyntax to be rewritten.
"End" keyword token for .
"If" keyword token for .
Rewritten EndIfStatementSyntax/EndIfDirectiveSyntax node.
This method checks for the following:
(a) Both the End keyword and If keyword, and respectively, are Missing tokens AND
(b) Descendant Trivia under the given token or token has an "EndIf" keyword token.
If the above conditions are met, it does the following node rewrites:
(a) Replace the missing and tokens with new "End" and "If" keywords tokens respectively.
(b) Remove the first "EndIf" keyword token from the descendant trivia and adjust the leading and trailing trivia appropriately.
this will put operator token and modifier tokens in right order
check whether given operator statement is valid or not
normalize operator
reorder modifiers in the list
normalize modifier list of the node and record changes if there is any change
normalize modifier list of the node and record changes if there is any change
remove "Dim" keyword if present
remove ByVal keyword from parameter list
remove a modifier from the given node
check whether given modifiers are in right order (in sync with ModifierKindsInOrder list)