Microsoft.CodeAnalysis.VisualBasic Analyzes method body for error conditions such as definite assignments, unreachable code etc... This analysis is done when doing the full compile or when responding to GetCompileDiagnostics. This method assume that the trees are already bound and will not do any rewriting/lowering It is possible and common for this analysis to be done in the presence of errors. Mutate 'self' flow analysis state to reflect the fact that there is a control-flow convergence with the 'other' flow analysis state. Return true if and only if the state has changed as a result of the Join. Mutate 'self' flow analysis state to reflect the fact that there is a control-flow sequence with the 'other' flow analysis state - in other words, this occurs and then the other. Produce a duplicate of this flow analysis state. BlockLevel is used to keep track of the lexical nesting level of label and goto statements. The other most block has a path of {} The state associated with a label includes the statement itself, the local state and the nesting. A pending branch. There are created for a return, break, continue, or goto statement. The idea is that we don't know if the branch will eventually reach its destination because of an intervening finally block that cannot complete normally. So we store them up and handle them as we complete processing each construct. At the end of a block, if there are any pending branches to a label in that block we process the branch. Otherwise we relay it up to the enclosing construct as a pending branch of the enclosing construct. Start of the region being analyzed, or Nothing if it is not a region based analysis End of the region being analyzed, or Nothing if it is not a region based analysis Current region span, valid only for region based analysis Tells whether we are analyzing the position before, during, or after the region A cache of the state at the backward branch point of each loop. This is not needed during normal flow analysis, but is needed for region analysis. Checks if the text span passed is inside the region Subclasses may override EnterRegion to perform any actions at the entry to the region. Subclasses may override LeaveRegion to perform any action at the end of the region. If invalid region is dynamically detected this string contains text description of the reason. Currently only the following case can cause the region to be invalidated: - We have declaration of several variables using 'As New' having object initializer with implicit receiver; if region included such a receiver, it should include the whole declaration. Example: Dim a, b As New Clazz(...) With { .X = [| .Y |] } - Part of With statement expression which was not captured into locals and was not evaluated during With statement body execution. Example: initializer with implicit receiver; if region included such a receiver, it should include the whole declaration. Example: Dim sArray() As StructType = ... With sArray([| 0 |]) End With The compilation in which the analysis is taking place. This is needed to determine which conditional methods will be compiled and which will be omitted. The symbol of method whose body is being analyzed or field or property whose initializer is being analyzed The bound code of the method or initializer being analyzed The flow analysis state at each label, computed by merging the state from branches to that label with the state when we fall into the label. Entries are created when the label is encountered. One case deserves special attention: when the destination of the branch is a label earlier in the code, it is possible (though rarely occurs in practice) that we are changing the state at a label that we've already analyzed. In that case we run another pass of the analysis to allow those changes to propagate. This repeats until no further changes to the state of these labels occurs. This can result in quadratic performance in unlikely but possible code such as this: "int x; if (cond) goto l1; x = 3; l5: print x; l4: goto l5; l3: goto l4; l2: goto l3; l1: goto l2;" All of the labels seen so far in this forward scan of the body Set to true after an analysis scan if the analysis was incomplete due to a backward "goto" branch changing some analysis result. In this case the caller scans again (until this is false). Since the analysis proceeds by monotonically changing the state computed at each label, this must terminate. Actual storage for PendingBranches The definite assignment and/or reachability state at the point currently being analyzed. 'Me' parameter, relevant for methods, fields, properties, otherwise Nothing Used only in the data flows out walker, we track unassignments as well as assignments The current lexical nesting in the BoundTree. Where all diagnostics are deposited. Indicates whether or not support of constant expressions (boolean and nothing) is enabled in this analyzer. In general, constant expressions support is enabled in analysis exposed to public API consumer and disabled when used from command-line compiler. Construct an object for outside-region analysis Construct an object for region-aware analysis Set conditional state Set unconditional state Split state Intersect and unsplit state Pending escapes generated in the current scope (or more deeply nested scopes). When jump statements (goto, break, continue, return) are processed, they are placed in the Me._pendingBranches buffer to be processed later by the code handling the destination statement. As a special case, the processing of try-finally statements might modify the contents of the Me._pendingBranches buffer to take into account the behavior of "intervening" finally clauses. Perform a single pass of flow analysis. Note that after this pass, this.backwardBranchChanged indicates if a further pass is required. False if the region is invalid False if the region is invalid If analysis is being performed in a context of a method returns method's parameters, otherwise returns an empty array Specifies whether or not method's ByRef parameters should be analyzed. If there's more than one location in the method being analyzed, then the method is partial and we prefer to report an out parameter in partial method error. Note: VB doesn't support "out" so it doesn't warn for unassigned parameters. However, check variables passed byref are assigned so that data flow analysis detects parameters flowing out. true if the out parameters of the method should be analyzed Method symbol or nothing TODO: Need to try and get rid of this property If analysis is being performed in a context of a method returns method's return type, otherwise returns Nothing Return the flow analysis state associated with a label. Set the current state to one that indicates that it is unreachable. Called at the point in a loop where the backwards branch would go to. Called at the point in a loop where the backward branch is placed. Used to resolve exit statements in each statement form that has an Exit statement (loops, switch). Used to resolve continue statements in each statement form that supports it. Subclasses override this if they want to take special actions on processing a goto statement, when both the jump and the label have been located. To handle a label, we resolve all pending forward references to branches to that label. Returns true if the state of the label changes as a result. When branching into constructs that don't support jumps into/out of (i.e. lambdas), we save the pending branches when visiting more nested constructs. We use this to restore the old set of pending branches and labels after visiting a construct that contains nested statements. The old pending branches/labels, which are to be merged with the current ones We look at all pending branches and attempt to resolve the branches with labels if the nesting of the block is the nearest common parent to the branch and the label. Because the code is evaluated recursively outward we only need to check if the current nesting is a prefix of both the branch and the label nesting. Report an unimplemented language construct. Visit a node. Visit a node, process Visit a boolean condition expression. Visit a general expression, where we will only need to determine if variables are assigned (or not). That is, we will not be needing AssignedWhenTrue and AssignedWhenFalse. Since each language construct must be handled according to the rules of the language specification, the default visitor reports that the construct for the node is not implemented in the compiler. Bound field access passed may require tracking if it is an access to a non-shared structure field If a receiver is included in cases where the receiver will not be evaluated (an instance for a shared method for instance), we still want to visit the receiver but treat it as unreachable code. A region analysis walker that computes the set of variables that are always assigned a value in the region. A variable is "always assigned" in a region if an analysis of the region that starts with the variable unassigned ends with the variable assigned. This class implements the region control flow analysis operations. Region control flow analysis provides information about statements which enter and leave a region. The analysis done lazily. When created, it performs no analysis, but simply caches the arguments. Then, the first time one of the analysis results is used it computes that one result and caches it. Each result is computed using a custom algorithm. A collection of statements outside the region that jump into the region. A collection of statements inside the region that jump to locations outside the region. Returns true if and only if the last statement in the region can complete normally or the region contains no statements. A collection of return, exit sub, exit function, exit operator and exit property statements found within the region that return to the enclosing method. Produce a duplicate of this flow analysis state. Perform control flow analysis, reporting all necessary diagnostics. Returns true if the end of the body might be reachable.. Intersect bit arrays taking into account 'all bits set' flag receiver will be changed as a result Produce a duplicate of this flow analysis state. Collection of 0, 1 or more slots. Allows returning of several slots by some DataFlowPass methods to handle cases where implicit receiver represents several variables, like in: Dim a, b, c As New C(...) With {...} Because such constructions are very rare in real user code, the collection only allocates an array builder for storing several values if there are indeed more than one slot to be stored. Because the collection may optionally create an array builder, collection's Free() method must be called when appropriate. Note that the collection is mutable, so one can add or modify the values. If some collection elements get replaced with 'SlotKind.NotTracked' collection does NOT "shrink", i.e. once allocated the array builder is not freed even if all the elements are set to 'SlotKind.NotTracked'. Collection cannot store 'SlotKind.Unreachable' (0) which has a special meaning. AmbiguousLocalsPseudoSymbol is a pseudo-symbol used in flow analysis representing a symbol of the implicit receiver in case Dim statement defines more than one variable, but uses the same object initializer for all of them, like: Dim a,b As New C() With { .X = .Y } Represents variable symbol combined with the containing variable slot Special slot for untracked variables Special slot for tracking whether code is reachable Special slot for tracking the implicit local for the function return value The first available slot for variables Some variables that should be considered initially assigned. Used for region analysis. Defines whether or not fields of intrinsic type should be tracked. Such fields should not be tracked for error reporting purposes, but should be tracked for region flow analysis Variables that were used anywhere, in the sense required to suppress warnings about unused variables. Variables that were initialized or written anywhere. A mapping from local variables to the index of their slot in a flow analysis local state. WARNING: if variable identifier maps into SlotKind.NotTracked, it may mean that VariableIdentifier is a structure without traceable fields. This mapping is created in MakeSlotImpl(...) A mapping from the local variable slot to the symbol for the local variable itself. This is used in the implementation of region analysis (support for extract method) to compute the set of variables "always assigned" in a region of code. Variable slots are allocated to local variables sequentially and never reused. This is the index of the next slot number to use. Tracks variables for which we have already reported a definite assignment error. This allows us to report at most one such error per variable. Did we see [On Error] or [Resume] statement? Used to suppress some diagnostics. Perform data flow analysis, reporting all necessary diagnostics. Locals are given slots when their declarations are encountered. We only need give slots to local variables, and the "Me" variable of a structure constructs. Other variables are not given slots, and are therefore not tracked by the analysis. This returns SlotKind.NotTracked for a variable that is not tracked, for fields of structs that have the same assigned status as the container, and for structs that (recursively) contain no data members. We do not need to track references to variables that occur before the variable is declared, as those are reported in an earlier phase as "use before declaration". That allows us to avoid giving slots to local variables before processing their declarations. Return the slot for a variable, or SlotKind.NotTracked if it is not tracked (because, for example, it is an empty struct). Force a variable to have a slot. Descends through Rest fields of a tuple if "symbol" is an extended field As a result the "symbol" will be adjusted to be the field of the innermost tuple and a corresponding containingSlot is returned. Return value -1 indicates a failure which could happen for the following reasons a) Rest field does not exist, which could happen in rare error scenarios involving broken ValueTuple types b) Rest is not tracked already and forceSlotsToExist is false (otherwise we create slots on demand) Calculates the flag of being already reported; for structure types the slot may be reported if ALL the children are reported Marks slot as reported, propagates 'reported' flag to the children if necessary Unassign a slot for a regular variable Assign a slot for a regular variable in a given state. Assign a slot for a regular variable. Hash structure fields as we may query them many times Check that the given variable is definitely assigned. If not, produce an error. Version of CheckAssigned for bound field access Check node for being assigned, return the value of unassigned slot in unassignedSlot Property controls Roslyn data flow analysis features which are disabled in command-line compiler mode to maintain backward compatibility (mostly diagnostics not reported by Dev11), but *enabled* in flow analysis API Specifies if the analysis should process compiler generated locals. Note that data flow API should never report compiler generated variables as well as those should not generate any diagnostics (like being unassigned, etc...). But when the analysis is used for iterators or async captures it should process compiler generated locals as well... Report a given variable as not definitely assigned. Once a variable has been so reported, we suppress further reports of that variable. Mark a variable as assigned (or unassigned). A variable declared with As New can be considered assigned before the initializer is executed in case the variable is a value type. The reason is that in this case the initialization happens in place (not in a temporary) and the variable already got the object creation expression assigned. A region analysis walker that computes the set of variables whose values flow into (are used in) the region. A variable assigned outside is used inside if an analysis that leaves the variable unassigned on entry to the region would cause the generation of "unassigned" errors within the region. A region analysis walker that computes the set of variables for which their assigned values flow out of the region. A variable assigned inside is used outside if an analysis that treats assignments in the region as un-assigning the variable would cause "unassigned" errors outside the region. A region analysis walker that computes the set of variables that are definitely assigned when a region is entered. A region analysis walker that records jumps into the region. Works by overriding NoteBranch, which is invoked by a superclass when the two endpoints of a jump have been identified. A region analysis walker that records jumps out of the region. Region being analyzed: start node Region being analyzed: end node Region itself The flow analysis pass. This pass reports required diagnostics for unreachable statements and uninitialized variables (through the call to FlowAnalysisWalker.Analyze). the method to be analyzed the method's body the receiver of the reported diagnostics A region analysis walker that records reads and writes of all variables, both inside and outside the region. Represents analysis context attributes such as compilation, region, etc... Current compilation Method, field or property symbol Bound node defining the root of the bound subtree to be analyzed Region being analyzed: start node Region being analyzed: end node Region itself True if the input was bad, such as no first and last nodes Construct context from model and region 'boundNode' defines a bound sub-tree to be analyzed and is being used in both region-based and not region based analysis processes. The last three parameters define a region. In most cases firstInRegion and lastInRegion are being used for identifying when we should enter or leave the region. Text span is also being passed to define the region which is used in few places. Those places can be rewritten to use first/last bound nodes, but simple [region.Contains(...)] check simplifies the code significantly. (Note, C# implementation uses the same logic, but calculates the region's text span based on first/last node; in VB to perform such calculation would have to traverse bound subtree under first/last nodes to detect region boundaries; we avoid this additional cost by passing the original text span as a separate parameter because we do have it anyways) Construct context with Failed flag A region analysis walker that computes whether or not the region completes normally. It does this by determining if the point at which the region ends is reachable. An analysis that computes the set of variables that may be used before being assigned anywhere within a method. A region analysis walker that records declared variables. This class implements the region data flow analysis operations. Region data flow analysis provides information how data flows into and out of a region. The analysis is done lazily. When created, it performs no analysis, but simply caches the arguments. Then, the first time one of the analysis results is used it computes that one result and caches it. Each result is computed using a custom algorithm. A collection of the local variables that are declared within the region. Note that the region must be bounded by a method's body or a field's initializer, so parameter symbols are never included in the result. A collection of the local variables for which a value assigned outside the region may be used inside the region. A collection of the local variables for which a value assigned inside the region may be used outside the region. A collection of the local variables for which a value is always assigned inside the region. A collection of the local variables that are read inside the region. A collection of local variables that are written inside the region. A collection of the local variables that are read outside the region. A collection of local variables that are written inside the region. A collection of the local variables that have been referenced in anonymous functions and therefore must be moved to a field of a frame class. A BoundForLoopStatement node has a list of control variables (from the attached next statement). When binding the control variable of a for/for each loop that is nested in another for/for each loop, it must be checked that the control variable has not been used by a containing for/for each loop. Because bound nodes do not know their parents and we try to avoid passing around a stack of variables, we just walk the bound tree after the initial binding to report this error. In addition, it must be checked that the control variables of the next statement match the loop. Because the inner most loop contains the next with control variables from outer binders, checking this here is also convenient. There are two diagnostics reported by this walker: 1. BC30069: For loop control variable '{0}' already in use by an enclosing For loop. 2. BC30070: Next control variable does not match For loop control variable '{0}'. Checks if the control variable was already used in an enclosing for loop Checks if the control variables from the next statement match the control variable of the enclosing for loop. Some loops may contain a next with multiple variables. Gets the referenced symbol of the bound expression. Used for matching variables between For and Next statements. The bound expression. Turns the bound initializers into a list of bound assignment statements Builds a constructor body. Lowers initializers to fields assignments if not lowered yet and the first statement of the body isn't a call to another constructor of the containing class. Bound block including - call to a base constructor - field initializers and top-level code - remaining constructor statements (empty for a submission) Rewrites GlobalStatementInitializers to ExpressionStatements and gets the initializers for fields and properties. Initializers for fields and properties cannot be rewritten to their final form at this place because they might need to be rewritten to replace their placeholder expressions to the final locals or temporaries (e.g. in case of a field declaration with "AsNew" and multiple variable names. The final rewriting will during local rewriting. The statement list returned by this function can be copied into the initializer without reprocessing it. Determines if this constructor calls another constructor of the constructor's containing class. A walker that computes the set of local variables of an iterator method that must be moved to fields of the generated class. Binder used for attributes Root syntax node Field or property declaration statement syntax node Some nodes have special binder's for their contents Binding info for attribute syntax and expressions that are part of a attribute. Creates an AttributeSemanticModel that allows asking semantic questions about an attribute node. Creates a speculative semantic model that allows asking semantic questions about an attribute node that did not appear in the original source code. Backstop that forms the end of the binder chain. Does nothing, and should never actually get hit. Provides asserts that methods never get called. Returns true if the node is in a position where an unbound type such as (C(of)) is allowed. Causes lookups to assume that the given set of classes are having their bases being resolved, so lookups should not check for base classes. A Binder object represents a general location from where binding is happening, and provides virtual methods for looking up unqualified names, reporting errors, and also other operations that need to know about where binding happened from (accessibility checking, etc.) It also contains most of the methods related to general binding of constructs, although some large sections are factored into their own classes. Yes, Binder is a big grab bag of features. The reason for this is that binders are threaded through essentially ALL binding functions. So, basically Binder has all the features that need to be threaded through binding. Binder objects form a linked list and each binder links to its containing binder. Each binder only handles operations that it knows how to handles, and passes on other calls to its containing binder. This maintains separation of concerns and allows binders to be strung together in various configurations to enable different binding scenarios (e.g., debugger expression evaluator). In general, binder objects should be constructed via the BinderBuilder class. Binder class has GetBinder methods that return binders for scopes nested into the current binder scope. One should not expect to get a binder from the functions unless a syntax that originates a scope is passed as the argument. Also, the functions do not cross lambda boundaries, if binder's scope contains a lambda expression, binder will not return any binders for nodes contained in the lambda body. In order to get them, the lambda must be bound to BoundLambda node, which exposes LambdaBinder, which can be asked for binders in the lambda body (but it will not descend into nested lambdas). Currently, only , and have special implementation of GetBinder functions, the rest just delegate to containing binder. If the binding context requires specific binding options, then modify the given lookup options accordingly. Lookup the given name in the binder and containing binders. Returns the result of the lookup. See the definition of LookupResult for details. This method is virtual, but usually there is no need to override it. It calls the virtual LookupInSingleBinder, which should be overridden instead, for each binder in turn, and merges the results. Overriding this method is needed only in limited scenarios, for example for a binder that binds query [Into] clause and has implicit qualifier. Lookup in just a single binder, without delegating to containing binder. The original binder passed in is used for accessibility checking and so forth. Collect extension methods with the given name that are in scope in this binder. The passed in ArrayBuilder must be empty. Extension methods from the same containing type must be grouped together. Lookup all names of extension methods that are available from a single binder, without delegating to containing binder. The original binder passed in is used for accessibility checking and so forth. Names that are available are inserted into "nameSet". This is a hashSet that accumulates names, and should be created with the VB identifierComparer. Lookups labels by label names, returns a label or Nothing Lookup all names that are available from a single binder, without delegating to containing binder. The original binder passed in is used for accessibility checking and so forth. Names that are available are inserted into "nameSet". This is a hashSet that accumulates names, and should be created with the VB identifierComparer. Determine if "sym" is accessible from the location represented by this binder. For protected access, use the qualifier type "accessThroughType" if not Nothing (if Nothing just check protected access with no qualifier). Overriding methods should consider . Determine if "sym" is accessible from the location represented by this binder. For protected access, use the qualifier type "accessThroughType" if not Nothing (if Nothing just check protected access with no qualifier). Some nodes have special binder's for their contents Some nodes have special binder's for their contents The member containing the binding context Additional members associated with the binding context Currently, this field is only used for multiple field/property symbols initialized by an AsNew initializer, e.g. "Dim x, y As New Integer" or "WithEvents x, y as New Object" Tells whether binding is happening in a query context. Tells whether binding is happening in a lambda context. Returns true if the node is in a position where an unbound type such as (C(of)) is allowed. The type containing the binding context Returns true if the binder is binding top-level script code. The namespace or type containing the binding context Get the built-in MSCORLIB type identified. If it's not available (an error type), then report the error with the given syntax and diagnostic bag. If the node and diagBag are Nothing, then don't report the error (not recommended). Type to get Where to report the error, if any. This is a layer on top of the Compilation version that generates a diagnostic if the well-known type isn't found. WARN: Retrieves the symbol but does not check its viability (accessibility, etc). This is a layer on top of the assembly version that generates a diagnostic if the well-known member isn't found. This is a layer on top of the Compilation version that generates a diagnostic if the well-known member isn't found. Get the source module. Get the compilation. Get an error symbol. Get the Location associated with a given TextSpan. Get a SyntaxReference associated with a given syntax node. Returns the syntax tree. Called in member lookup right before going into the base class of a type. Results a set of named types whose bases classes are currently in the process of being resolved, so we shouldn't look into their bases again to prevent/detect circular references. Nothing if no bases being resolved, otherwise the set of bases being resolved. Called during member lookup before going into the base class of a type. If returns true, the base class is ignored. Primarily used for binding Imports. Current Option Strict mode. True if Option Infer On is in effect. False if Option Infer Off is in effect. True if Option Explicit On is in effect. False if Option Explicit Off is in effect. Note that even if Option Explicit Off is in effect, there are places (field initializers) where implicit variable declaration is not permitted. See the ImplicitVariablesDeclarationAllowedHere property also. True if Option Compare Text is in effect. False if Option Compare Binary is in effect. True if integer overflow checking is On. True if implicit variable declaration is available within this binder, and the binder has already finished binding all possible implicit declarations inside (and is not accepting) any more. True if implicit variable declaration is allow by the language here. Differs from OptionExplicit in that it is only try if this binder is associated with a region that allows implicit variable declaration (field initializers and attributes don't, for example). Declare an implicit local variable. The type of the local is determined by the type character (if any) on the variable. Get all implicitly declared variables that were declared in this method body. Disallow additional local variable declaration and report delayed shadowing diagnostics. Get the label that a Exit XXX statement should branch to, or Nothing if we are not inside a context that would be exited by that kind of statement. The passed in kind is the SyntaxKind for the exit statement that would target the label (e.g. SyntaxKind.ExitDoStatement). Get the label that a Continue XXX statement should branch to, or Nothing if we are not inside a context that would be exited by that kind of statement. The passed in kind is the SyntaxKind for the exit statement that would target the label (e.g. SyntaxKind.ContinueDoStatement). Get the label that a Return statement should branch to, or Nothing if we are not inside a context that would be exited by that kind of statement. This method is equivalent to calling with the appropriate exit . Get the special local symbol with the same name as the enclosing function. Create a diagnostic at a particular syntax node and place it in a diagnostic bag. Issue an error or warning for a symbol if it is Obsolete. If there is not enough information to report diagnostics, then store the symbols so that diagnostics can be reported at a later stage. Also, check runtime/language support for the symbol. Returns the type of construct being bound (BaseTypes, MethodSignature, etc.) to allow the Binder to provide different behavior in certain cases. Currently, this property is only used by ShouldCheckConstraints. Returns true if the binder is performing early decoding of a (well-known) attribute. Return True if type constraints should be checked when binding. Returns True if the binder, or any containing binder, has xmlns Imports. Add { prefix, namespace } pairs from the explicitly declared namespaces in the XmlElement hierarchy. The order of the pairs is the order the xmlns attributes are declared on each element, and from innermost to outermost element. This method reports use site errors if a required attribute constructor is missing. Some attributes are considered to be optional (e.g. the CompilerGeneratedAttribute). In this case the use site errors will be ignored. This method reports use site errors if a required attribute constructor is missing. Some attributes are considered to be optional (e.g. the CompilerGeneratedAttribute). In this case the use site errors will be ignored. Returns a placeholder substitute for a With statement placeholder specified or Nothing if not found Note: 'placeholder' is needed to make sure the binder can check that the placeholder is associated with the statement. Indicates that this binder is being used to answer SemanticModel questions (i.e. not for batch compilation). Imports touched by a binder with this flag set are not consider "used". Binder to be used for binding New With { ... } expressions. If set, the state of the binder shouldn't be modified by subsequent binding operations, which could be performed by SemanticModel in context of this binder. Having this binder, which is created for each field initializer within AnonymousObjectCreationExpressionSyntax gives us the following advantages: - We no longer rely on transient state of AnonymousTypeField objects to detect out of order field references within initializers. This way we can be sure that result of binding performed by SemanticModel is consistent with result of initial binding of the entire node. - AnonymousTypeCreationBinder overrides CreateAnonymousObjectCreationExpression in such a way that it mutates its state. That overridden method shouldn't be called while we are binding each initializer (by queries, for example), it should be called only by AnonymousTypeCreationBinder itself after all initializers are bound and we are producing the resulting node. So having an extra binder in between takes care of that. Gets but does not fully validate a symbol's attributes. Returns binding errors but not attribute usage and attribute specific errors. Walk a custom attribute argument bound node and return a TypedConstant. Verify that the expression is a constant expression. This function must return a BoundConversion node in case of non-identity conversion. This function must return a BoundConversion node in case of explicit or non-identity conversion. This function must return a BoundConversion node in case of non-identity conversion. Returns True if error or warning was reported. This function is invoked on the occasion of a Narrowing or NoConversion. It looks at the conversion. If the conversion could have been helped by variance in some way, it reports an error/warning message to that effect and returns true. This message is a substitute for whatever other conversion-failed message might have been displayed. Note: these variance-related messages will NOT show auto-correct suggestion of using CType. That's because, in these cases, it's more likely than not that CType will fail, so it would be a bad suggestion Handle expression reclassification, if any applicable. If function returns True, the "argument" parameter has been replaced with result of reclassification (possibly an error node) and appropriate diagnostic, if any, has been reported. If function returns false, the "argument" parameter must be unchanged and no diagnostic should be reported. conversionSemantics can be one of these: SyntaxKind.CTypeKeyword, SyntaxKind.DirectCastKeyword, SyntaxKind.TryCastKeyword Structure is used to store all information which is needed to construct and classify a Delegate creation expression later on. Binds the AddressOf expression. The AddressOf expression node. The diagnostics. Binds the delegate creation expression. This comes in form of e.g. Dim del as new DelegateType(AddressOf methodName) Type of the delegate. The argument list. Syntax node to attach diagnostics to in case the argument list is nothing. The diagnostics. Resolves the target method for the delegate and classifies the conversion The bound AddressOf expression itself. The delegate type to assign the result of the AddressOf operator to. Resolves the method for delegate invoke with all or relaxed arguments / return types. It also determines the method conversion kind. The AddressOf expression. The delegate invoke method. Ignore method's return type for the purpose of calculating 'methodConversions'. The diagnostics. The resolved method if any. Resolves the method for delegate invoke with all or relaxed arguments / return types. It also determines the method conversion kind. The AddressOf expression. The delegate invoke method. Ignore method's return type for the purpose of calculating 'methodConversions'. The diagnostics. if set to true use zero argument relaxation. The resolved method if any. Determines the method conversion for delegates based on the arguments. The resolution result. The delegate invoke method. Classifies the address of conversion. The bound AddressOf expression. The target type to convert this AddressOf expression to. Checks if a parameter is a ParamArray and reports this as an error. The containing type. The current parameter token. The flags of this parameter. The diagnostics. Reclassifies the bound address of operator into a delegate creation expression (if there is no delegate relaxation required) or into a bound lambda expression (which gets a delegate creation expression later on) The AddressOf expression. The delegate resolution result. Type of the target. The diagnostics. Build a lambda that has a shape of the [delegateInvoke] and calls the only method from the [methodGroup] passing all parameters of the lambda as arguments for the call. Note, that usually the receiver of the [methodGroup] should be captured before entering the relaxation lambda in order to prevent its reevaluation every time the lambda is invoked and prevent its mutation. !!! Therefore, it is not common to call this overload directly. !!! Location to use for various synthetic nodes and symbols. The Invoke method to "implement". The method group with the only method in it. Delegate relaxation to store within the new BoundLambda node. Report a diagnostic, and also produce an error expression with error type. Report a diagnostic, and also produce an error expression with error type. Report a diagnostic, and also produce an error expression with error type. Report a diagnostic, and also produce an error expression with error type. Report a diagnostic, and also produce an error expression with error type. The dispatcher method that handles syntax nodes for all stand-alone expressions. Create a BoundBadExpression node for the given syntax node. No symbols or bound nodes are associated with it. Create a BoundBadExpression node for the given child-expression, which is preserved as a sub-expression. No ResultKind is associated Create a BoundBadExpression node for the given child-expression, which is preserved as a sub-expression. A ResultKind explains why the node is bad. Create a BoundBadExpression node for the given child expression, which is preserved as a sub-expression. Symbols associated with the child node are not given a result kind. Removes duplicate entries in and frees it if only nulls remain. Returns the type to be used as a field type. This function is only needed for SemanticModel to perform binding for erroneous cases. BindValue evaluates the node and returns a BoundExpression. BindValue snaps expressions to values. For now that means that method groups become invocations. Adjusts receiver of a call or a member access. * will turn Unknown property access into Get property access * will turn TypeOrValueExpression into a value expression Adjusts receiver of a call or a member access if the receiver is an ambiguous BoundTypeOrValueExpression. This can only happen if the receiver is the LHS of a member access expression in which the RHS cannot be resolved (i.e. the RHS is an error or a late-bound invocation/access). Adjusts receiver of a call or a member access if it is a value * will turn Unknown property access into Get property access BindRValue evaluates the node and returns a BoundExpression. It ensures that the expression is a value that can be used on the right hand side of an assignment. If not, it reports an error. Note that this function will reclassify all expressions to have their "default" type, i.e. Anonymous Delegate for a lambda, default array type for an array literal, will report an error for an AddressOf, etc. So, if you are in a context where there is a known target type for the expression, do not use this function. Instead, use BindValue followed by ApplyImplicitConversion/ApplyConversion. Determine whether field access should be treated as LValue. Return MethodKind corresponding to the method the code being interpreted is going to end up in. Process the result of dominant type inference, generate diagnostics True if inside in binding arguments of constructor call with {'Me'/'MyClass'/'MyBase'}.New(...) from another constructor Can we access MyBase in this location. If False is returned, also returns the error id associated with that. Can we access Me in this location. If False is returned, also returns the error id associated with that. Can we access MyClass in this location. If False is returned, also returns the error id associated with that. Second part of BindSimpleName. It is a separate function so that it could be called directly when we have already looked up for the name. Method binds member access in case when we got hold of a bound node representing the left expression The method is protected, so that it can be called from other binders overriding TryBindMemberAccessWithLeftOmitted Returns a bound node for left part of member access node with omitted left syntax. In particular it handles member access inside With statement. By default the method delegates the work to it's containing binder or returns Nothing. Specifies the binder which requests an access to the bound node for omitted left. NOTE: in some cases, like for binding inside anonymous object creation expression, this method returns bound node for the whole expression rather than only for omitted left part. Given a localSymbol and a syntaxNode where the symbol is used, safely return the symbol's type. The local symbol The syntax node that references the symbol diagnostic bag if errors are to be reported Returns the symbol's type or an ErrorTypeSymbol if the local is referenced before its definition or if the symbol is still being bound. This method safely returns a local symbol's type by checking for circular references or references before declaration. Report diagnostics relating to access shared/nonshared symbols. Returns true if an ERROR (but not a warning) was reported. Also replaces receiver as a type with DefaultPropertyInstance when appropriate. Returns a bound node for left part of dictionary access node with omitted left syntax. In particular it handles dictionary access inside With statement. By default the method delegates the work to it's containing binder or returns Nothing. Handle ArrayCreationExpressionSyntax new integer(n)(,) {...} new integer() {...} Binds CollectionInitializeSyntax. i.e. { expr, ... } from an ArrayCreationExpressionSyntax The collection initializer syntax The type of array. This is in/out. It comes in with sizes from explicit bounds but will be updated based on the number of initializers for dimensions without bounds Where to put errors Binds CollectionInitializeSyntax. i.e. { expr, ... } from an ArrayCreationExpressionSyntax The collection initializer syntax This is in/out. It comes in with sizes from explicit bounds but will be updated based on the number of initializers for dimensions without bounds When the inferred type is Object() indicates that the dominant type algorithm computed this type. The number of candidates found during inference The inferred element type Where to put errors Bind the array bounds and return the sizes for each dimension. The bounds Where to put the errors The bounds if they are constants, if argument is not specified this info is not returned The Imports binder handles binding of Imports statements in files, and also the project-level imports. Checks use site error and returns True in case it should be reported for the alias. In current implementation checks for errors #36924 and #36925 Used to store the bound field and property initializers and the associated list of bound assignment statements because they are reused for multiple constructors Indicate the fact that binding of initializers produced a tree with errors. This property does not indicate whether or not a diagnostic was produced during the binding of the initializers. Binds all field initializers of a . The named type symbol where the field initializers are declared. Script initializer or Nothing if not binding top-level statements. The initializers itself. For each partial type declaration there is an array of field initializers The diagnostics. Bind an initializer for an implicitly allocated array field (for example: Private F(2) As Object). Binds the field initializer. A bound field initializer contains the bound field access and bound init value. The field symbol. The syntax node for the optional initialization. The array of bound initializers to add the newly bound ones to. The diagnostics. Checks for errors in the constant initialization of a field, and only returns a BoundFieldOrPropertyInitializer for decimals and dates because they aren't compile time constant in CLR. Other data type end up directly in metadata and do not cause a BoundFieldOrPropertyInitializer node. The field symbol. The syntax node for the optional initialization. The array of bound initializers to add the newly bound ones to. Binds constant initialization value of the field. The symbol. The initialization syntax. The diagnostics. Binds a constant local's value. The local symbol. The local symbol's type. It is passed in because this method is called while the type is being resolved and before it is set. Binds a parameter's default value syntax Returns if all the rules for a "Me.New" or "MyBase.New" constructor call are satisfied: a) In instance constructor body b) First statement of that constructor c) "Me", "MyClass", or "MyBase" is the receiver. Bind a Me.New(...), MyBase.New (...), MyClass.New(...) constructor call. (NOT a normal constructor call like New Type(...)). Bind an invocation expression representing an array access, delegate invocation, or default member. Returns a BoundPropertyGroup if the expression represents a valid default property access. If there is a default property but the property access is invalid, a BoundBadExpression is returned. If there is no default property for the expression type, Nothing is returned. Note, that default Query Indexer may be a method, not a property. Tests whether or not the method or property group should be bound without arguments. In case of method group it may also update the group by filtering out all subs Optimizes some runtime library calls through replacing them with a literal if possible. VB Spec 11.2 defines the following runtime functions as being constant: - Microsoft.VisualBasic.Strings.ChrW - Microsoft.VisualBasic.Strings.Chr, if the constant value is between 0 and 128 - Microsoft.VisualBasic.Strings.AscW, if the constant string is not empty - Microsoft.VisualBasic.Strings.Asc, if the constant string is not empty The method. The arguments of the method call. The syntax node for report errors. The diagnostics. Set to true if there are conversion errors (e.g. Asc("")). Otherwise it's not written to. The constant value that replaces this node, or nothing. Figure out the set of best candidates in the following preference order: 1) Applicable 2) ArgumentMismatch, GenericConstraintsViolated 3) TypeInferenceFailed 4) ArgumentCountMismatch 5) BadGenericArity 6) Ambiguous 7) HasUseSiteError 8) HasUnsupportedMetadata Also return the set of unique symbols behind the set. Returns type symbol for the common type, if any. Otherwise returns ErrorTypeSymbol.UnknownResultType. Should be kept in sync with OverloadResolution.MatchArguments. Anything that OverloadResolution.MatchArguments flags as an error should be detected by this function as well. Should be in sync with OverloadResolution.MatchArgumentToByRefParameter Should be in sync with OverloadResolution.MatchArgumentToByValParameter. Should be kept in sync with OverloadResolution.MatchArguments, which populates data this function operates on. Return true if the node is an immediate child of a call statement. If we are inside a lambda in a constructor and are passing ByRef a non-LValue field, which would be an LValue field, if it were referred to in the constructor outside of a lambda, we need to report an error because the operation will result in a simulated pass by ref (through a temp, without a copy back), which might be not the intent. Collects expressions that are effective return values of the lambda body. In iterators those would be arguments of Yield statements. Used by Add*LookupSymbolsInfo* to determine whether the symbol is of interest. Distinguish from , which performs an analogous task for LookupSymbols*. Does not consider - that is left to the caller. This class handles binding of members of namespaces and types. The key member is Lookup, which handles looking up a name in a namespace or type, by name and arity, and produces a lookup result. Lookup a member name in a namespace or type, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussing of the meaning of the results. The supplied binder is used for accessibility checked and base class suppression. Lookup a member name in a namespace, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussing of the meaning of the results. The supplied binder is used for accessibility checked and base class suppression. Lookup an immediate (without descending into modules) member name in a namespace, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussion of the meaning of the results. The supplied binder is used for accessibility checks and base class suppression. Lookup a member name in modules of a namespace, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussion of the meaning of the results. The supplied binder is used for accessibility checks and base class suppression. Lookup a member name in a type, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussing of the meaning of the results. The supplied binder is used for accessibility checked and base class suppression. Lookup a member name in a module, class, struct, enum, or delegate, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussing of the meaning of the results. The supplied binder is used for accessibility checks and base class suppression. This function generalizes the idea of producing a set of non-conflicting WinRT members of a given type based on the results of some arbitrary lookup closure (which produces a LookupResult signifying success as IsGood). A non-conflicting WinRT member lookup looks for all members of projected WinRT interfaces which are implemented by a given type, discarding any which have equal signatures. If is true then this function lookups up members with the given , , and . Otherwise, it looks for default properties. Lookup a member name in a submission chain. We start with the current submission class and walk the submission chain back to the first submission. The search has two phases 1) We are looking for any symbol matching the given name, arity, and options. If we don't find any the search is over. If we find an overloadable symbol(s) (a method or a property) we start looking for overloads of this kind (lookingForOverloadsOfKind) of symbol in phase 2. 2) If a visited submission contains a matching member of a kind different from lookingForOverloadsOfKind we stop looking further. Otherwise, if we find viable overload(s) we add them into the result. Overloads modifier is ignored. Include the InternalXmlHelper.Value extension property in the LookupResult if the container implements IEnumerable(Of XElement), the name is "Value", and the arity is 0. Checks if two interfaces have a base-derived relationship Merges two lookup results while eliminating symbols that are shadowed. Note that the final result may contain unrelated and possibly conflicting symbols as this helper is not intended to catch ambiguities. If is not Nothing and False filters out all Event symbols, and if is not Nothing and True filters out all non-Event symbols, nos not have any effect otherwise. Is used for special handling of Events inside COM interfaces. first.Where(t IsNot Nothing).Concat(second.Where(t IsNot Nothing)) if any symbol in the list Shadows. This implies that name is not visible through the base. Lookup a member name in a type without considering inheritance, returning a LookupResult that summarizes the results of the lookup. See LookupResult structure for a detailed discussing of the meaning of the results. Binds the object collection or member initializer from a object creation. E.g. "new CollType() From {...}" or "new AType() With {...}" The type of the created object expression. The object creation expression syntax. The diagnostics. Bind the ObjectInitializer. During the binding we basically bind the member access for each initializer, as well as the value that will be assigned. The main information stored in the bound node is a list of assignment operators (that may contain placeholders), as well as the information whether expression creates a temporary or not. Binds a object collection initializer. During the binding of this node we are binding calls to Add methods of the created object. Once the "collection" type passed the requirements (same as for each collection requirements + must have accessible Add method), all diagnostics are handled by the overload resolution. The bound node contains a list of call expressions (that may contain placeholders). Binds a call expression for a given top level object collection initializer. Validate and apply appropriate conversion for the target argument of Is/IsNot expression. This helper is used to wrap nullable argument into something that would return null string if argument is null. Unlike conversion to a string where nullable nulls result in an exception, concatenation requires that nullable nulls are treated as null strings. Note that conversion is treated as explicit conversion. This function builds a bound tree representing an overloaded short circuiting expression after determining that the necessary semantic conditions are met. An expression of the form: x AndAlso y (where the type of x is X and the type of y is Y) is an overloaded short circuit operation if X and Y are user-defined types and an applicable operator And exists after applying normal operator resolution rules. Given an applicable And operator declared in type T, the following must be true: - The return type and parameter types must be T. - T must contain a declaration of operator IsFalse. If these conditions are met, the expression "x AndAlso y" is translated into: !T.IsFalse(temp = x) ? T.And(temp, y) : temp The temporary is necessary for evaluating x only once. Similarly, "x OrElse y" is translated into: !T.IsTrue(temp = x) ? T.Or(temp, y) : temp Returns Symbol for String type. Get symbol for a special type, reuse symbols for operand types to avoid type lookups and construction of new instances of symbols. Get symbol for a Nullable type of particular type, reuse symbols for operand types to avoid type lookups and construction of new instances of symbols. §11.12.2 Object Operands The value Nothing is treated as the default value of the type of the other operand in a binary operator expression. In a unary operator expression, or if both operands are Nothing in a binary operator expression, the type of the operation is Integer or the only result type of the operator, if the operator does not result in Integer. Bind a Query Expression. This is the entry point. Given a result of binding of initial set of collection range variables, the source, bind the rest of the operators in the enumerator. There is a special method to bind an operator of each kind, the common thing among them is that all of them take the result we have so far, the source, and return result of an application of one or two following operators. Some of the methods also take operators enumerator in order to be able to do a necessary look-ahead and in some cases even to advance the enumerator themselves. Join and From operators absorb following Select or Let, that is when the process of binding of a single operator actually handles two and advances the enumerator. Bind query expression that starts with From keyword, as opposed to the one that starts with Aggregate. From {collection range variables} [{other operators}] Bind query expression that starts with Aggregate keyword, as opposed to the one that starts with From. Aggregate {collection range variables} [{other operators}] Into {aggregation range variables} If Into clause has one item, a single value is produced. If it has multiple items, values are combined into an instance of an Anonymous Type. Given result of binding preceding query operators, the source, bind the following Aggregate operator. {Preceding query operators} Aggregate {collection range variables} [{other operators}] Into {aggregation range variables} Depending on how many items we have in the INTO clause, we will interpret Aggregate operator as follows: FROM a in AA FROM a in AA AGGREGATE b in a.BB => LET count = (FROM b IN a.BB).Count() INTO Count() FROM a in AA FROM a in AA AGGREGATE b in a.BB => LET Group = (FROM b IN a.BB) INTO Count(), Select a, Count=Group.Count(), Sum=Group.Sum(b=>b) Sum(b) Apply implicit Select operator at the end of the query to ensure that at least one query operator is called. Basically makes query like: From a In AA into: From a In AA Select a Given result of binding preceding query operators, the source, bind the following Select operator. {Preceding query operators} Select {expression range variables} From a In AA Select b ==> AA.Select(Function(a) b) From a In AA Select b, c ==> AA.Select(Function(a) New With {b, c}) Given result of binding preceding query operators, the source, bind the following Let operator. {Preceding query operators} Let {expression range variables} Ex: From a In AA Let b ==> AA.Select(Function(a) New With {a, b}) Ex: From a In AA Let b, c ==> AA.Select(Function(a) New With {a, b}).Select(Function({a, b}) New With {a, b, c}) Note, that preceding Select operator can introduce unnamed range variable, which is dropped by the Let Ex: From a In AA Select a + 1 Let b ==> AA.Select(Function(a) a + 1).Select(Function(unnamed) b) Also, depending on the amount of expression range variables declared by the Let, and the following query operators, translation can produce a nested, as opposed to flat, compound variable. Ex: From a In AA Let b, c, d ==> AA.Select(Function(a) New With {a, b}). Select(Function({a, b}) New With {{a, b}, c}). Select(Function({{a, b}, c}) New With {a, b, c, d}) In some scenarios, it is safe to leave compound variable in nested form when there is an operator down the road that does its own projection (Select, Group By, ...). All following operators have to take an Anonymous Type in both cases and, since there is no way to restrict the shape of the Anonymous Type in method's declaration, the operators should be insensitive to the shape of the Anonymous Type. In some scenarios, it is safe to leave compound variable in nested form when there is an operator down the road that does its own projection (Select, Group By, ...). All following operators have to take an Anonymous Type in both cases and, since there is no way to restrict the shape of the Anonymous Type in method's declaration, the operators should be insensitive to the shape of the Anonymous Type. Given result of binding preceding query operators, if any, bind the following From operator. [{Preceding query operators}] From {collection range variables} Ex: From a In AA ==> AA Ex: From a In AA, b in BB ==> AA.SelectMany(Function(a) BB, Function(a, b) New With {a, b}) Ex: {source with range variable 'd'} From a In AA, b in BB ==> source.SelectMany(Function(d) AA, Function(d, a) New With {d, a}). SelectMany(Function({d, a}) BB, Function({d, a}, b) New With {d, a, b}) Note, that preceding Select operator can introduce unnamed range variable, which is dropped by the From Ex: From a In AA Select a + 1 From b in BB ==> AA.Select(Function(a) a + 1). SelectMany(Function(unnamed) BB, Function(unnamed, b) b) Also, depending on the amount of collection range variables declared by the From, and the following query operators, translation can produce a nested, as opposed to flat, compound variable. Ex: From a In AA From b In BB, c In CC, d In DD ==> AA.SelectMany(Function(a) BB, Function(a, b) New With {a, b}). SelectMany(Function({a, b}) CC, Function({a, b}, c) New With {{a, b}, c}). SelectMany(Function({{a, b}, c}) DD, Function({{a, b}, c}, d) New With {a, b, c, d}) If From operator translation results in a SelectMany call and the From is immediately followed by a Select or a Let operator, they are absorbed by the From translation. When this happens, operatorsEnumerator is advanced appropriately. Ex: From a In AA From b In BB Select a + b ==> AA.SelectMany(Function(a) BB, Function(a, b) a + b) Ex: From a In AA From b In BB Let c ==> AA.SelectMany(Function(a) BB, Function(a, b) new With {a, b, c}) See comments for BindFromClause method, this method actually does all the work. Given result of binding preceding query operators, the outer, bind the following Join operator. [{Preceding query operators}] Join {collection range variable} [{additional joins}] On {condition} Ex: From a In AA Join b in BB On Key(a) Equals Key(b) ==> AA.Join(BB, Function(a) Key(a), Function(b) Key(b), Function(a, b) New With {a, b}) Ex: From a In AA AA.Join( Join b in BB BB.Join(CC, Function(b) Key(b), Function(c) Key(c), Join c in CC ==> Function(b, c) New With {b, c}), On Key(c) Equals Key(b) Function(a) Key(a), Function({b, c}) Key(b), On Key(a) Equals Key(b) Function(a, {b, c}) New With {a, b, c}) Also, depending on the amount of collection range variables in scope, and the following query operators, translation can produce a nested, as opposed to flat, compound variable. Ex: From a In AA AA.Join(BB, Function(a) Key(a), Function(b) Key(b), Join b in BB Function(a, b) New With {a, b}). On Key(a) Equals Key(b) Join(CC, Function({a, b}) Key(a, b), Function(c) Key(c), Join c in CC ==> Function({a, b}, c) New With {{a, b}, c}). On Key(c) Equals Key(a, b) Join(DD, Function({{a, b}, c}) Key(a, b, c), Function(d) Key(d), Join d in DD Function({{a, b}, c}, d) New With {a, b, c, d}) On Key(a, b, c) Equals Key(d) If Join is immediately followed by a Select or a Let operator, they are absorbed by the translation. When this happens, operatorsEnumerator is advanced appropriately. Ex: From a In AA Join b in BB On Key(a) Equals Key(b) ==> AA.Join(BB, Function(a) Key(a), Function(b) Key(b), Select a + b Function(a, b) a + b) Ex: From a In AA Join b in BB On Key(a) Equals Key(b) ==> AA.Join(BB, Function(a) Key(a), Function(b) Key(b), Let c Function(a, b) New With {a, b, c}) Given result of binding preceding query operators, the outer, bind the following Group Join operator. [{Preceding query operators}] Group Join {collection range variable} [{additional joins}] On {condition} Into {aggregation range variables} Ex: From a In AA Group Join b in BB AA.GroupJoin(BB, Function(a) Key(a), Function(b) Key(b), On Key(a) Equals Key(b) ==> Function(a, group_b) New With {a, group_b.Count()}) Into Count() Also, depending on the amount of collection range variables in scope, and the following query operators, translation can produce a nested, as opposed to flat, compound variable (see BindInnerJoinClause for an example). Note, that type of the group must be inferred from the set of available GroupJoin operators in order to be able to interpret the aggregation range variables. Given result of binding preceding query operators, the source, bind the following Group By operator. [{Preceding query operators}] Group [{items expression range variables}] By {keys expression range variables} Into {aggregation range variables} Ex: From a In AA Group By Key(a) AA.GroupBy(Function(a) Key(a), Into Count() ==> Function(key, group_a) New With {key, group_a.Count()}) Ex: From a In AA Group Item(a) AA.GroupBy(Function(a) Key(a), By Key(a) ==> Function(a) Item(a), Into Count() Function(key, group_a) New With {key, group_a.Count()}) Note, that type of the group must be inferred from the set of available GroupBy operators in order to be able to interpret the aggregation range variables. Returns Nothing if items were omitted. Infer type of the group for a Group By operator from the set of available GroupBy methods. In short, given already bound itemsLambda and keysLambda, this method performs overload resolution over the set of available GroupBy operator methods using fake Into lambda: Function(key, group As typeToBeInferred) New With {group} If resolution succeeds, the type inferred for the best candidate is our result. Infer type of the group for a Group Join operator from the set of available GroupJoin methods. In short, given already bound inner source and the join key lambdas, this method performs overload resolution over the set of available GroupJoin operator methods using fake Into lambda: Function(outerVar, group As typeToBeInferred) New With {group} If resolution succeeds, the type inferred for the best candidate is our result. This is a helper method to create a BoundQueryLambda for an Into clause of a Group By or a Group Join operator. Given result of binding preceding query operators, the source, bind the following Where operator. {Preceding query operators} Where {expression} Ex: From a In AA Where a > 0 ==> AA.Where(Function(a) a > b) Given result of binding preceding query operators, the source, bind the following Skip While operator. {Preceding query operators} Skip While {expression} Ex: From a In AA Skip While a > 0 ==> AA.SkipWhile(Function(a) a > b) Given result of binding preceding query operators, the source, bind the following Take While operator. {Preceding query operators} Take While {expression} Ex: From a In AA Skip While a > 0 ==> AA.TakeWhile(Function(a) a > b) This helper method does all the work to bind Where, Take While and Skip While query operators. Given result of binding preceding query operators, the source, bind the following Distinct operator. {Preceding query operators} Distinct Ex: From a In AA Distinct ==> AA.Distinct() Given result of binding preceding query operators, the source, bind the following Skip operator. {Preceding query operators} Skip {expression} Ex: From a In AA Skip 10 ==> AA.Skip(10) Given result of binding preceding query operators, the source, bind the following Take operator. {Preceding query operators} Take {expression} Ex: From a In AA Take 10 ==> AA.Take(10) This helper method does all the work to bind Take and Skip query operators. Given result of binding preceding query operators, the source, bind the following Order By operator. {Preceding query operators} Order By {orderings} Ex: From a In AA Order By a ==> AA.OrderBy(Function(a) a) Ex: From a In AA Order By a.Key1, a.Key2 Descending ==> AA.OrderBy(Function(a) a.Key1).ThenByDescending(Function(a) a.Key2) This is a top level binder used to bind bodies of query lambdas. It also contains a bunch of helper methods to bind bodies of a particular kind. Bind body of a lambda representing Select operator selector in context of this binder. Bind Select like selector based on the set of expression range variables in context of this binder. Bind ExpressionRangeVariableSyntax in context of this binder. Bind Let operator selector for a particular ExpressionRangeVariableSyntax. Takes care of "carrying over" of previously declared range variables as well as introduction of the new one. Bind body of a lambda representing first Select operator selector for an aggregate clause in context of this binder. Bind Join/From selector that absorbs following Select/Let in context of this binder. Bind Join/Let like and mixed selector in context of this binder. Join like selector: Function(a, b) New With {a, b} Let like selector: Function(a) New With {a, letExpressionRangeVariable} Mixed selector: Function(a, b) New With {a, b, letExpressionRangeVariable} Bind key selectors for a Join/Group Join operator. Helper visitor to determine what join sides are referenced by an expression. Helper visitor to report query specific errors for an operand of an Equals expression. Knows how to bind FunctionAggregationSyntax and GroupAggregationSyntax within particular [Into] clause. Also implements Lookup/LookupNames methods to make sure that lookup without container type, uses type of the group as the container type. Given aggregationVariables, bind Into selector in context of this binder. Bind AggregationRangeVariableSyntax in context of this binder. Same as IntoClauseBinder, but disallows references to GroupAggregationSyntax. Bind CollectionRangeVariableSyntax, applying AsQueryable/AsEnumerable/Cast(Of Object) calls and Select with implicit type conversion as appropriate. Apply "conversion" to the source based on the target AsClause Type of the CollectionRangeVariableSyntax. Returns implicit BoundQueryClause or the source, in case of an early failure. Convert source expression to queryable type by inferring control variable type and applying AsQueryable/AsEnumerable or Cast(Of Object) calls. In case of success, returns possibly "converted" source and non-Nothing controlVariableType. In case of failure, returns passed in source and Nothing as controlVariableType. Given query operator source, infer control variable type from available 'Select' methods. Returns inferred type or Nothing. Given a set of 'Select' methods, infer control variable type. Returns inferred type or Nothing. Given a method, infer control variable type. Returns inferred type or Nothing. Return method group or Nothing in case nothing was found. Note, returned group might have ResultKind = "Inaccessible". [methodGroup] can be Nothing if lookup didn't find anything. The dispatcher method that handles syntax nodes for all stand-alone statements. Check presence of [On Error]/[Resume] statements and report diagnostics based on presence of other "incompatible" statements. Report Async/Await diagnostics, which depends on surrounding context. Defines max allowed rank of the array Currently set to 32 because of COM+ array type limits Decodes a set of local declaration modifier flags and reports any errors with the flags. The syntax list of the modifiers. returns True if any errors are reported Compute the type of a local symbol using the type character, as clause and equals value expression. 1. Try to compute the type based on the identifier/modified identifier and as clause. If there is a type then we're done. 2. If OptionInfer is on then evaluate the expression and use that to infer the type. ComputeVariableType will only bind the value if the symbol does not have an explicit type. The local symbol The symbols modified identifier is there is one The optional as clause The optional initializing expression The bound initializing expression The bound as clause type Infer the type of a for-from-to control variable. Infer the type of a for-each control variable. Infer the type of a variable declared with an initializing expression. Verifies that declaration of a local symbol does not cause name clashes. Should be called on the binder, at which the check should begin. Binds a list of statements and puts in a scope. Binds a list of statements and puts in a scope. Binds all the common part for ForTo and ForEach loops except the loop body and the next variables. The node. The control variable syntax. The declared or inferred local symbol. The control variable. The diagnostics. true if there were errors; otherwise false Binds loop body and the next variables for ForTo and ForEach loops. The binding of the loop body and the next variables cannot happen before the local type inference has completed, which happens in the specialized binding functions for foreach and for loops. Otherwise we would loose the diagnostics from the type inference. The loop body. The next variables. Can return Nothing in case of failure. Verifies for control variable declaration and outputs diagnostics as needed. The variable declarator. The diagnostics. This function tries to bind the given controlVariableSyntax. If it was an identifier of a valid target, the bound node is written to controlVariable and true is returned. If something else was bound, that is not legal as a control variable (e.g. a property), a BoundBadNode is written to controlVariable and false is returned. If nothing declared was found, false is returned and controlVariable is set to nothing. In this case it's safe to create a new local for the loop node. If the control variable was bound to a non bad expression, this function checks if the bound expression is a variable and reports diagnostics appropriately. It reports the errors from 10.9.3 2.2 The control variable. The diagnostics. Verifies that the collection is either a string, and array or matches the design pattern criteria and reports diagnostics appropriately. The collection of the for each statement. If the collection meets all criteria, currentType contains the type of the element from the collection that get's returned by the current property. Element type of the collection, could be different from . For example, based on the pattern for an array is Object, but the is the element type of the array. if set to true, the collection is enumerable (matches design pattern, IEnumerable or IEnumerable(Of T); otherwise (string or arrays) it's set to false. The diagnostics. The collection which might have been converted to IEnumerable or IEnumerable(Of T) if needed. Checks if the type of the collection matches the for each collection design pattern. The rules are that the collection type must have an accessible GetEnumerator method that takes no parameters and returns a type that has both: - an accessible MoveNext method that takes no parameters and returns a Boolean - an accessible Current property that takes no parameters and is not WriteOnly NOTE: this function ONLY checks for a function named "GetEnumerator" with the appropriate properties. In the spec $10.9 it has these conditions: a type C is a "collection type" if one of (1) it satisfies MatchesForEachCollectionDesignPattern (i.e. has a method named GetEnumerator() which returns a type with MoveNext/Current); or (2) it implements System.Collections.Generic.IEnumerable(Of T); or (3) it implements System.Collections.IEnumerable. This function ONLY checks for part (1). Callers are expected to check for (2)/(3) themselves. The scenario where something satisfies (2/3) but not (1) is Class C Implements IEnumerable Function g1() as IEnumerator implements IEnumerable.GetEnumerator : End Function Clearly this class does not have a method _named_ GetEnumerator, but it does implement IEnumerable. The type of the for each collection. The bound collection expression. Return type of the property named "Current" if found. A bound call to GetEnumerator on the collection if found. A bound placeholder value for the collection local if GetEnumerator was bound successful A bound call to MoveNext on the instance returned by GetEnumerator if found. A bound property access for "Current" on the instance returned by GetEnumerator if found. A placeholder for the collection expression. An empty diagnostic bag to capture diagnostics that have to be reported if the collection matches the design pattern and that can be used instead of the generic error message in case non of the for each collection criteria match. If all required methods have been successfully looked up and bound, true is being returned; otherwise false. Creates a BoundCall or BoundPropertyAccess from a MethodOrPropertyGroup. This is not a general purpose helper! The syntax node. The method or property group. The diagnostics. Checks if a given symbol is a function that takes no parameters. Checks if a given symbol is a property that is readable. Returns the lookup result if at least one found symbol matches the requirements that are verified by using the given symbolChecker. Extension methods will be considered in this check. The name of the method or property to look for. The container to look in. The symbol checker which performs additional checks. Determines whether derivedType is, inherits from or implements the given interface. The possible derived type. Type of the interface. A list of matching interfaces. true if derivedType is, inherits from or implements the interface; otherwise, false. Initially binding using blocks. A Using statement names a resource that is supposed to be disposed on completion. The resource can be an expression or a list of local variables with initializers. the type of the resource must implement System.IDispose A using statement of the form: using Expression list_of_statements end using when the resource is a using locally declared variable no temporary is generated but the variable is read-only A using statement of the form: using v as new myDispose list_of_statements end using It is also possible to use multiple variable resources: using v1 as new myDispose, v2 as myDispose = new myDispose() list_of_statements end using Check the given type of and report WRN_MutableGenericStructureInUsing if needed. This function should only be called for a type of a using variable. Binds a sync lock block. A SyncLock come in the following form: SyncLock <expression> <body> End SyncLock The node. The diagnostics. Bind a type name using the given binder. Returns a type symbol if the binding bound to something, or an error symbol if the binding failed. In either case, errors may be reported via the context. For example, if an inaccessible type or type with the wrong arity was found, the best possible type is returned, but an error is also generated. The syntax to bind. Place to put diagnostics. If no reasonable type was found, an undefined type diagnostic is placed in here. Other diagnostics (both related to the type being bound, or type arguments thereof) can be placed here also. The best type that can be found, or and ErrorTypeSymbol if no reasonable type can be found. Bind a type or namespace using the given binder. The syntax to bind. The best type or namespace that can be found, or and ErrorTypeSymbol if no reasonable type can be found. Apply generic type arguments, returning the constructed type. Produces errors for constraints that aren't validated. If the wrong number of type arguments are supplied, the set of types is silently truncated or extended with the type parameters. The type to construct from The types to apply The place to report errors for the generic type as a whole The place to report errors for each generic type argument. The diagnostics collection. The constructed generic type. The type binder class handles binding of type names. Bind a type name using the given binder. Returns a type symbol if the binding bound to something, or an error symbol if the binding failed. In either case, errors may be reported via the context. For example, if an inaccessible type or type with the wrong arity was found, the best possible type is returned, but an error is also generated. The syntax to bind. The binder to bind within. This binder is used for looking up unqualified names, accessibility checking, reporting errors, and probably other stuff too. The best type that can be found, or and ErrorTypeSymbol if no reasonable type can be found. If lookup failed for a qualified name, we don't know which part of the lookup failed. Therefore, we have to check for a type forwarder for each prefix of the name. Starting assembly. Full name of type that failed lookup. Shortened as different prefixes are checked. GetBaseNamesForDiagnostic(typeSyntax) (basically dot-delimited list of names). Shortened as different prefixes are checked. Set if some prefix matches a forwarded type. Diagnostics bag (Nothing if errors should not be reported). Look for a type forwarder for the given type in the containing assembly and any referenced assemblies. If one is found, search again in the target assembly. Return the last assembly in the chain. The assembly in which to look for the type forwarder. The metadata name of the (potentially) forwarded type, including the arity (if non-zero). The arity of the forwarded type. The syntax to report types on (if any). The diagnostics bag (Nothing if errors should not be reported). Since this method is intended to be used for error reporting, it stops as soon as it finds any type forwarder (or an error to report). It does not check other assemblies for consistency or better results. NOTE: unlike in C#, this method searches for type forwarders case-insensitively. Bind a type or namespace using the given binder. The syntax to bind. The binder to bind within. This binder is used for looking up unqualified names, accessibility checking, reporting errors, and probably other stuff too. The best type or namespace that can be found, or and ErrorTypeSymbol if no reasonable type can be found. Lookup a typeSyntax, confining the lookup to namespaces or types. Returns a LookupResult that summarizes the results of the lookup, which might contain a Diagnostic associated with the lookup. However, other diagnostics associated with parts of the binding process (i.e., binding type arguments) will be emitted via the diagnostic bag. The LookupResult will always have at most one symbol in it, since types and namespaces are not overloadable symbols. Bind a built in type name to the correct type symbol. Bind array type syntax to the correct type symbol. Bind Nullable (?) type syntax to the correct type symbol. Bind a basic name to a type or namespace. Bind a generic name to a type. Bind a dotted name to a type or namespace. Bind a generic dotted name to a type or namespace. Bind to the global namespace. Bind a list of type arguments to their types. Given a type syntax, strip out ?, (), (of xxx) stuff and return a string of the form x.y.z, for use in an error message. If the identifier has a type character, report an error on it. Given a list of keywords and a set of keywords kinds to search, return the first keyword in the list, if any, that matches one of the keyword kinds. Map syntax kind of a modifier keyword to SourceMemberFlags value Decodes a set of modifier flags, reported any errors with the flags. The syntax list of the modifiers. A bit-flag of the allowable modifiers. If a bit isn't set, an error occurs. Error ID to report if a bad modifier is found. The default accessibility. Flags for the modifiers. Decode a list of parameter modifiers, and return the flags associated with it. Create the Nullable version of a type. Possible create the array version of type, given the element type and the array modifier syntax. Possibly create the array version of type, given the element type and the array modifier syntax. Create the array version of type, given the element type and the array modifier syntax. Throws if there aren't any array modifiers and the result is not an array type. Given an identifier and an As clause, return true if the identifier does not have a type declared for it (e.g., no type character and no as clause). Given an identifier and an As clause, return true if the identifier does not have a type declared for it (e.g., no type character and no as clause). Given an identifier, return true if the identifier declares an array. (e.g., identifier specifies ()) Flags to specify where the decoding of the modified identifier's type happens. No context given (default). Modified identifier appeared in a lambda declaration. Modified identifier appeared in a local declaration. Modified identifier appeared in a field declaration. Modified identifier appeared in a parameter. Modified identifier appeared in a query range variable declaration. Combined flag to express that a modified identifier appeared in a local or field declaration. Combined flag to express that a modified identifier appeared in a parameter of a lambda. Given a modified identifier and a type, return the actual type to use. Applies the type character and type modifiers to the given type. The modified identifier. Bound type after the As or a type from the initializing value expression. Can be nothing if no type was supplied. If specified then it is the syntax for the as clause and the type is the bound type from this syntax. Delegate to get diagnostic info to generate if a required type is missing (Option Strict On/Custom) The type, as modified by the type character, type modifiers. Uses Object as default if needed. Given a modified identifier and a type syntax, return the actual type to use. Applies the type character and type modifiers to the given type. The modified identifier. As clause syntax. Can be nothing if no type was supplied. Delegate to get diagnostic info to generate if a required type is missing (Option Strict On/Custom) The type of the AsClauseOpt before applying any modifiers The type, as modified by the type character, type modifiers. Uses Object as default if needed. Given a modified identifier and a type syntax, return the actual type to use. Applies the type character and type modifiers to the given type. The modified identifier. As clause syntax. Can be nothing if no type was supplied. Delegate to get diagnostic info to generate if a required type is missing (Option Strict On/Custom) The type, as modified by the type character, type modifiers. Uses Object as default if needed. Given a identifier and as clause syntax, return the actual type to use. Uses the type character or the type syntax. The identifier. Syntax for optional as clause. Can be nothing if no type was supplied. Delegate to get diagnostic info to generate if a required type is missing (Option Strict On/Custom) The type, either from the type character or the as clause. Uses Object as default if needed. Given a identifier and as clause syntax, return the actual type to use. Uses the type character or the type syntax. The identifier. Syntax for optional as clause. Can be nothing if no type was supplied. Delegate to get diagnostic info to generate if a required type is missing (Option Strict On/Custom) The type, either from the type character or the as clause. Uses Object as default if needed. Given a identifier and a type, return the actual type to use. Uses the type character or the given type. The identifier. Bound type after the As. Can be nothing if no type was supplied. Delegate to get diagnostic info to generate if a required type is missing (Option Strict On/Custom) The type, either from the type character or the as clause type. Uses Object as default if needed. Decode an option "On" or "Off" values into true or false. Not specified is considered true. Decode an option "Text" or "Binary" value into true or false. The syntax is not optional. Decode a parameter list from a delegate declaration into a list of parameter symbols. Containing method declaration. Optional parameter list syntax Decode a parameter list into a list of parameter symbols. Containing method declaration. Parameter is for a lambda expression rather than a regular method. Optional parameter list syntax DO NOT call this to get the parameters of a delegate declaration (DecodeParameterListOfDelegateDeclaration). Decode a parameter list into a list of parameter symbols. Containing property declaration. Optional parameter list syntax Modifier validation code shared between properties and methods. This function checks if the given expression is a constant from a language point of view and returns constant value if it is. This is different from the fact that the bound node has a constant value. This method also adds the required diagnostics for non const values. The bound expression. The diagnostics. ConstantValue if the bound expression is compile time constant and can be used for const field/local initializations or enum member initializations. Nothing if not isWinMd says whether to mangle the name for winmdobj output. See the param tag for details. isWinMd is only necessary for set properties, so any MethodKind which is definitely not a set property can safely set this value to False. Returns True if the xmlns { prefix, namespace } pair matches an Imports declaration and there aren't any xmlns declarations for the same prefix on any outer XElement scopes. Bind the expression within the XmlEmbeddedExpressionSyntax, and wrap in a BoundXmlEmbeddedExpression. If the method or property group is not Nothing, bind as an invocation expression. Otherwise return a BoundBadExpression containing the arguments. Check if XML features are allowed. If not, report an error and return a separate DiagnosticBag that can be used for binding sub-expressions. Bind any xmlns declaration attributes and return the bound nodes plus a Dictionary of { prefix, namespace } pairs that will be used for namespace lookup at and below the containing XmlElement. Any xmlns declarations that are redundant with Imports in scope (same prefix and namespace) are dropped, and instead, an entry is added to the 'importedNamespaces' collection. When the root XmlElement is generated, xmlns attributes will be added for all entries in importedNamespaces. Any attributes other than xmlns are added to the 'otherAttributes' collection for binding by the caller. If the attribute represents an xmlns declaration, populate 'prefix' and 'namespace', and generate diagnostics and set hasErrors if there are errors. Returns True if this is an xmlns declaration, even if there are errors. Unless this attribute is from an Imports statement, generate the BoundExpression for the namespace as well. (For Imports, binding is skipped, since a BoundNode is not needed, and in the invalid case of "xmlns:p=<%= expr %>", expr may result in a cycle. If name is "xmlns", set prefix to String.Empty and return True. If name is "xmlns:p", set prefix to p and return True. Otherwise return False. State tracked for the root XmlElement while binding nodes within the tree. This state is mutable since it includes the set of namespaces from Imports referenced within the tree. Ideally, this state would be part of the XmlRootElementBinder, but since this state is mutable, there would be issues caching and reusing the Binder. Instead, the state is passed explicitly as an argument to each binding method. Makes it look like Option Strict is Off, all other operations are delegated up the chain. A BinderBuilder builds a linked list of Binder objects for various typical binders. Typically the binder chain looks something like this: BackstopBinder SourceModuleBinder TypesOfImportedNamespacesMembersBinder (for modules of project-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for project-level imported namespaces and types) ImportAliasesBinder (for project-level import aliases) SourceFileBinder TypesOfImportedNamespacesMembersBinder (for modules of file-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for file-level imported namespaces and types) ImportAliasesBinder (for file-level import aliases) NamespaceBinder... (for each namespace, starting at the global namespace) TypeBinder... (for each type, and nested type) (maybe more) DiagnosticBagBinder Note: Binders are also built by the BinderCache class. Changes to how namespace and type Binders are built may need changes there also. Creates a binder for a binding global imports in a source file. This includes the following binders: BackstopBinder SourceModuleBinder SourceFileBinder NamespaceBinder (for the global namespace) IgnoreBaseClassesBinder (so that base classes are ignore during binding) Creates a binder for a binding project-level imports. This includes the following binders: BackstopBinder SourceModuleBinder ProjectImportsBinder NamespaceBinder (for the global namespace) IgnoreBaseClassesBinder (so that base classes are ignore during binding) Creates a binder for a source file. This includes the following binders: BackstopBinder SourceModuleBinder TypesOfImportedNamespacesMembersBinder (for modules of project-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for project-level imported namespaces and types) ImportAliasesBinder (for project-level import aliases) SourceFileBinder TypesOfImportedNamespacesMembersBinder (for modules of file-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for file-level imported namespaces and types) ImportAliasesBinder (for file-level import aliases) Creates a binder for a project level namespace declaration This includes the following binders: BackstopBinder SourceModuleBinder TypesOfImportedNamespacesMembersBinder (for modules of project-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for project-level imported namespaces and types) SourceFileBinder TypesOfImportedNamespacesMembersBinder (for modules of file-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for file-level imported namespaces and types) ImportAliasesBinder (for file-level import aliases) NamespaceBinder... (for each namespace, starting at the global namespace) Creates a binder for a source namespace declaration (the part of a namespace in a single namespace declaration). This includes the following binders: BackstopBinder SourceModuleBinder TypesOfImportedNamespacesMembersBinder (for modules of project-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for project-level imported namespaces and types) SourceFileBinder TypesOfImportedNamespacesMembersBinder (for modules of file-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for file-level imported namespaces and types) ImportAliasesBinder (for file-level import aliases) NamespaceBinder... (for each namespace, starting at the global namespace) Creates a binder for a source type declaration (the part of a type in a single type declaration. For partial types this include just one part). This includes the following binders: BackstopBinder SourceModuleBinder TypesOfImportedNamespacesMembersBinder (for modules of project-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for project-level imported namespaces and types) SourceFileBinder TypesOfImportedNamespacesMembersBinder (for modules of file-level imported namespaces) ImportedTypesAndNamespacesMembersBinder (for file-level imported namespaces and types) ImportAliasesBinder (for file-level import aliases) NamespaceBinder... (for each namespace, starting at the global namespace) NamedTypeBinder... (for each type, and nested type) Creates a binder for a source attribute block from the containing type or containing namespace. This binder is used by the normal compilation code path for source attributes. In this case, no containing binder exists. The symbol which is the target of the attribute. Creates a binder for a source attribute block when a containing binder is available. Used by semantic model. Creates a binder for binding a source parameter's default value. Creates a binder for binding for binding inside the interior of documentation comment Create a binder for the source module. Includes the following: BackstopBinder SourceModuleBinder The class finds the correct Binder to use for a node in a syntax tree, down to method level. Within a method, the has a cache of further binders within the method. The caches results so that binders are efficiently reused between queries. A helper to bind conditional access. Data for Binder.BindImportClause that exposes dictionaries of the members and aliases that have been bound during the execution of BindImportClause. It is the responsibility of derived classes to update the dictionaries in AddMember and AddAlias. Provides context for binding body of a Lambda. Special binder for binding ObjectInitializers. This binder stores a reference to the receiver of the initialization, because fields in an object initializer can be referenced with an omitted left expression in a member access expression (e.g. .Fieldname = .OtherFieldname). Use the receiver of the ObjectCreationExpression as the omitted left of a member access. Use the receiver of the ObjectCreationExpression to as the omitted left of a dictionary access. Holds information about a member in a compact form. Used for all non-type members for simplicity These are the flags that are found in the syntax. They must correspond to the modifiers list. These are flags that are implied or computed Binder used to bind statements inside With blocks. Reference to a With statement syntax this binder is created for Reference to an expression from With statement Holds information needed by With block to properly bind references to With block expression placeholder True if there were references to the With statement expression placeholder which prevent ByRef local from being used With statement expression placeholder is a bound node being used in initial binding to represent with statement expression. In lowering it is to be replaced with the lowered expression which will actually be emitted. A draft version of initializers which will be used in this With statement. Initializers are expressions which are used to capture expression in the current With statement; they can be empty in some cases like if the expression is a local variable of value type. Note, the initializers returned by this property are 'draft' because they are generated based on initial bound tree, the real initializers will be generated in lowering based on lowered expression form. A draft version of placeholder substitute which will be used in this With statement. Note, the placeholder substitute returned by this property is 'draft' because it is generated based on initial bound tree, the real substitute will be generated in lowering based on lowered expression form. Holds information needed by With block to properly bind references to With block expression, placeholder, etc... Original bound expression from With statement Bound placeholder expression if used, otherwise Nothing Diagnostics produced while binding the expression Draft initializers for With statement, is based on initial binding tree and is only to be used for warnings generation as well as for flow analysis and semantic API; real initializers will be re-calculated in lowering Draft substitute for With expression placeholder, is based on initial binding tree and is only to be used for warnings generation as well as for flow analysis and semantic API; real substitute will be re-calculated in lowering If With statement expression is being used from nested lambda there are some restrictions to the usage of Me reference in this expression. As these restrictions are only to be checked in few scenarios, this flag is being calculated lazily. Create a new instance of With statement binder for a statement syntax provided A bound tree walker which search for a bound Me and MyClass references of value type. Is being only used for calculating the value of 'ExpressionHasByRefMeReference' Asserts that the node is NOT from With statement expression Binding state used by the rewriter for XContainer derived types. A binder to expose namespaces from Imports<xmlns:...> statements. A binder for XmlElement declarations. An extension property in reduced form, with first parameter removed and exposed as an explicit receiver type. Get an instance suitable for concurrent additions to both underlying bags. A specific location for binding. Binder used to bind Catch blocks. It hosts the control variable (if one is declared) and inherits BlockBaseBinder since there are no Exit/Continue for catch blocks. This is used while computing the values of constant fields. Since they can depend on each other, we need to keep track of which ones we are currently computing in order to avoid (and report) cycles. This binder keeps track of the set of constant fields that are currently being evaluated so that the set can be passed into the next call to SourceFieldSymbol.ConstantValue (and its callers). Binder used for field, auto property initializations and parameter default values. Backing field for the ContainingMember property Backing field for the AdditionalContainingMembers property Root syntax node Initializes a new instance of the class. The field, property or parameter symbol with an initializer or default value. Additional field for property symbols initialized with the initializer. The next binder. Root syntax node The member containing the binding context. This property is the main reason for this binder, because the binding context for an initialization needs to be the field or property symbol. Additional members associated with the binding context Currently, this field is only used for multiple field/property symbols initialized by an AsNew initializer, e.g. "Dim x, y As New Integer" or "WithEvents x, y as New Object" Field or property declaration statement syntax node This binder keeps track of the set of parameters that are currently being evaluated so that the set can be passed into the next call to ParameterSymbol.DefaultConstantValue (and its callers). This binder keeps track of the set of symbols that are currently being evaluated so that the set can be passed to methods to support breaking infinite recursion cycles. Provides a way to obtain binders for descendant scopes in method or lambda body. Factory for a method body does not create binders for scopes inside a lambda, contained by the method. A dedicated factory must be created for each lambda body. Binder used for interiors of documentation comment Assuming there is one, the containing member of the binder is the commented symbol if and only if the commented symbol is a non-delegate named type. (Otherwise, it is the containing type or namespace of the commented symbol.) Delegates don't have user-defined members, so it makes more sense to treat them like methods. Symbol commented with the documentation comment handled by this binder. In general, all name lookup is being performed in context of this symbol's containing symbol. We still need this symbol, though, to be able to find type parameters or parameters referenced from 'param', 'paramref', 'typeparam' and 'typeparamref' tags. Removes from symbol collection overridden methods or properties Binder used for interiors of documentation comment for binding 'cref' attribute value Binder used for interiors of documentation comment for binding 'name' attribute value of 'param' and 'paramref' documentation comment tags Binder used for interiors of documentation comment for binding 'name' attribute value of 'typeparam' documentation comment tag Binder used for interiors of documentation comment for binding 'name' attribute value of 'typeparamref' documentation comment tag This is a binder for use when early decoding of well known attributes. The binder will only bind expressions that can appear in an attribute. Its purpose is to allow a symbol to safely decode any attribute without the possibility of any attribute related infinite recursion during binding. If an attribute and its arguments are valid then this binder returns a BoundAttributeExpression otherwise it returns a BadExpression. Check that the syntax can appear in an attribute argument. A ExecutableCodeBinder provides context for looking up labels within a context represented by a syntax node, and also implementation of GetBinder. Binder for Finally blocks. Its purpose is to hide exit try label of the enclosing try binder. Holds all information needed to rewrite a bound for each node. A bound call to the GetEnumerator method. A bound call to the MoveNext method. A bound access to the Current property. Element type of the collection. True is the enumerator needs or may need (in case of IEnumerator) to be disposed. True if the enumerator is, inherits from or implements IDisposable. The condition that is used to determine whether to call Dispose or not (contains a placeholder). The conversion of the enumerator to the target type on which Dispose is called (contains a placeholder). The conversion of the return value of the current call to the type of the control variable (contains a placeholder). Placeholder for the bound enumerator local. Placeholder for the bound call to the get_Current method. Placeholder for the collection; used only when the collection's type is not an one dimensional array or string. Initializes a new instance of the class. A bound call to the GetEnumerator method. A bound call to the MoveNext method. A bound access to the Current property. An element type. if set to true the enumerator needs to be disposed. if set to true the enumerator is or inherits from or implements IDisposable. The condition whether to call dispose or not. The conversion of the enumerator to call Dispose on. The conversion from Current return type to the type of the controlVariable. The placeholder for the bound enumerator local. The placeholder for the expression that get's the current value. The placeholder for the collection expression. Binder used to bind For and ForEach blocks. It hosts the control variable (if one is declared) and inherits ExitableStatementBinder to provide Continue/Exit labels if needed. This binder is for binding the argument to GetType. It traverses the syntax marking each open type ("unbound generic type" in the VB spec) as either allowed or not allowed, so that BindType can appropriately return either the corresponding type symbol or an error type. This visitor walks over a type expression looking for open types. Open types are allowed if an only if: 1) There is no constructed generic type elsewhere in the visited syntax; and 2) The open type is not used as a type argument or array/nullable element type. The argument to typeof. Keys are GenericNameSyntax nodes representing unbound generic types. Values are false if the node should result in an error and true otherwise. Causes lookups to ignore base classes. Used for binding Imports statements. If Option Explicit is Off for this source file, then implicit variable declaration will be allowed in this binder. "containerOfLocals" is the container for implicitly declared variables. Disallow additional local variable declaration (make binder frozen) and report delayed shadowing diagnostics. True if implicit variable declaration is done (binder is frozen and doesn't allow additional implicit variable declaration) True if we are in a place that allows implicit variable declaration. This binder implies that. Get all implicitly declared variables that were declared in this method body. The binder must be frozen before this can be obtained. Declare an implicit local variable. The type of the local is determined by the type character (if any) on the variable. A tricky problem is reporting the "Variable 'x' hides a variable in an enclosing block" message if the variable in an enclosing block is an implicit variable that hasn't been declared yet. We handle this by remembering any variable declarations in enclosed blocks, and then report the error when the implicit variable is declared. A ImportAliasesBinder provides lookup for looking up import aliases (A = Goo.Bar), either at file level or project level. Provides lookup in imported namespaces and types (not the alias kind), either at file level or project level. Collect extension methods with the given name that are in scope in this binder. The passed in ArrayBuilder must be empty. Extension methods from the same containing type must be grouped together. Creates an InitializerSemanticModel that allows asking semantic questions about an initializer node. Creates a speculative semantic model that allows asking semantic questions about an initializer node that did not appear in the original source code. The is used to build up the map of all s within a method body, and the associated . To do so it traverses all the statements, handling blocks and other statements that create scopes. For efficiency reasons, it does not traverse into expressions. This means that blocks within lambdas and queries are not created. Blocks within lambdas are bound by their own when they are analyzed. For reasons of lifetime management, this type is distinct from the which also creates a map from to . That type owns it's binders and that type's lifetime is that of the compilation. Therefore we do not store binders local to method bodies in that type's cache. Creates binders for top-level executable statements. This binder is for binding the initializer of an implicitly typed local variable. While binding an implicitly typed local variable this binder is used to break cycles. A simple Binder that wraps another Binder and reports a specific binding location, but otherwise delegates to the other Binder. Options that can be used to modify the symbol lookup mechanism. Multiple options can be combined together. Consider all symbols, using normal accessibility rules. Consider only namespaces and types. Consider only labels. If this is not set, labels are not considered at all. Do not consider symbols that are shared members. Do not consider symbols that are instance members. Do not consider the return value local variable. This is similar to the C# LookupOption.MustBeInvocableMember. The only non-invocable member in Visual Basic is the function return variable (see language specification 10.1.1). If this flag is set, lookup will not return the function return variable, but instead return the containing function or property, and any overloads thereof. Do not do lookup in base classes (similar to how types in Imports are bound). Ignore accessibility checking when determining if a symbol is a viable match. Consider methods of any arity (but still consider arity for other types of symbols). Do not look for extension methods. Ensures that lookup eagerly looks for extension methods and merges them with instance methods, if any. If this flag is not set and lookup found viable instance method, it will not look for extension methods that might be in scope. It is not an error to combine this flag with LookupOptions.IgnoreExtensionMethods, the LookupOptions.IgnoreExtensionMethods takes precedence. Consider only methods. Used by Query Expressions. 11.21.2 Queryable Types When binding well-known method names, non-methods are ignored for the purpose of multiple inheritance in interfaces and extension method binding, although shadowing semantics still apply. Ignore 'throughType' in accessibility checking. Used in checking accessibility of symbols accessed via 'MyBase'. Do not consider locals or parameters during lookup. Consider only events. Used to indicate that lookup searches for events only. Is used to change lookup semantic for searching inside interfaces having CoClass attribute defined. Essentially this is a special casing for searching events (and non-event symbols) in COM interfaces, see the following example from Dev11 code: Performing a lookup in a CoClass interface affects how we treat ambiguities between events and other members. In COM, events are separated into their own binding space, thus it is possible for an event and member to have the same name. This is not possible in the .NET world, but for backwards compatibility, especially with Office, the compiler will ignore ambiguities when performing a lookup in a CoClass interface. Example: Interface _Goo Sub Quit Interface GooSource Event Quit < System.Runtime.InteropServices.CoClass(GetType(GooClass)) > Interface Goo : Inherits _Goo, GooSource Class GooClass : Implements Goo Event Quit Implements Goo.Quit Sub Quit Implements Goo.Quit When performing a lookup in interface do NOT lookup in System.Object Handle a case of being able to refer to System.Int32 through System.Integer. Same for other intrinsic types with intrinsic name different from emitted name. Represents a result of lookup operation over a 0 or 1 symbol (as opposed to a scope). The typical use is to represent that a particular symbol is good/bad/unavailable. For more explanation of Kind, Symbol, Error - see LookupResult. A LookupResult summarizes the result of a name lookup, and allows combining name lookups from different scopes in an easy way. A LookupResult can be ONE OF: empty - nothing found. a non-accessible result - this kind of result means that search continues into further scopes of lower priority for a viable result. An error is attached with the inaccessibility errors. Non-accessible results take priority over non-viable results. a non-viable result - a result that means that the search continues into further scopes of lower priority for a viable or non-accessible result. An error is attached with the error that indicates why the result is non-viable. a bad symbol that stops further lookup - this kind of result prevents lookup into further scopes of lower priority. a diagnostic is attached explaining why the symbol is bad. ambiguous symbols.- In this case, an AmbiguousSymbolDiagnostic diagnostic has the other symbols. a good symbol, or set of good overloaded symbols - no diagnostic is attached in this case Occasionally, good or ambiguous results are referred to as "viable" results. Multiple symbols can be represented in a single LookupResult. Multiple symbols are ONLY USED for overloadable entities, such as methods or properties, and represent all the symbols that overload resolution needs to consider. When ambiguous symbols are encountered, a single representative symbols is returned, with an attached AmbiguousSymbolDiagnostic from which all the ambiguous symbols can be retrieved. This implies that Lookup operations that are restricted to namespaces and/or types always create a LookupResult with 0 or 1 symbol. Note that the class is poolable so its instances can be obtained from a pool via GetInstance. Also it is a good idea to call Free on instances after they no longer needed. The typical pattern is "caller allocates / caller frees" - Dim result = LookupResult.GetInstance() scope.Lookup(result, "goo") ... use result ... result.Clear() anotherScope.Lookup(result, "moo") ... use result ... result.Free() 'result and its content is invalid after this Set current result according to another Set current result according to another Set current result according to a given symbol Merge two results, returning the best. If there are multiple viable results, either produce a result with both symbols if they can overload each other, or use the current. Other result. If the checkIfCurrentHasOverloads is True, then we only overload if every symbol in our current result has "Overloads" modifier; otherwise we overload regardless of the modifier. Returns: negative value - when first lost, 0 - when neither lost, > 0 - when second lost. Returns: negative value - when current lost, 0 - when neither lost, > 0 - when other lost. Returns: negative value - when first lost, 0 - when neither lost, > 0 - when second lost. Returns: negative value - when namespace lost, 0 - when neither lost, > 0 - when type lost. Replace the symbol replaced with a new one, but the kind and diagnostics retained from the current result. Typically used when constructing a type from a symbols and type arguments. Binding info for expressions and statements that are part of a member declaration. Instances of this class should not be exposed to external consumers. Get the highest bound node in the tree associated with a particular syntax node. Get the lowest bound node in the tree associated with a particular syntax node. Lowest is defined as last in a pre-order traversal of the bound tree. If node has an immediate parent that is an expression or statement or attribute, return that (making sure it can be bound on its own). Otherwise return Nothing. Get a summary of the bound nodes associated with a particular syntax nodes, and its parent. This is what the rest of the semantic model uses to determine what to return back. Gets a summary of the bound nodes associated with an underlying bound call node for a raiseevent statement. if "node" argument is a BoundRaiseEvent, returns its underlying boundcall instead. Otherwise returns "node" unchanged. Return True if the statement can be bound by a Binder on its own. For example Catch statement cannot be bound on its own, only as part of Try block. Similarly, Next statement cannot be bound on its own, only as part of For statement. Only handles statements that are in executable code. Get all of the syntax errors within the syntax tree associated with this object. Does not get errors involving declarations or compiling method bodies or initializers. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. Get all the syntax and declaration errors within the syntax tree associated with this object. Does not get errors involving compiling method bodies or initializers. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. The declaration errors for a syntax tree are cached. The first time this method is called, a ll declarations are analyzed for diagnostics. Calling this a second time will return the cached diagnostics. Get all the syntax and declaration errors within the syntax tree associated with this object. Does not get errors involving compiling method bodies or initializers. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. The declaration errors for a syntax tree are cached. The first time this method is called, a ll declarations are analyzed for diagnostics. Calling this a second time will return the cached diagnostics. Get all the errors within the syntax tree associated with this object. Includes errors involving compiling method bodies or initializers, in addition to the errors returned by GetDeclarationDiagnostics. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. Because this method must semantically all method bodies and initializers to check for diagnostics, it may take a significant amount of time. Unlike GetDeclarationDiagnostics, diagnostics for method bodies and initializers are not cached, the any semantic information used to obtain the diagnostics is discarded. Given a type declaration, get the corresponding type symbol. The syntax node that declares a type. The type symbol that was declared. Given a enum declaration, get the corresponding type symbol. The syntax node that declares an enum. The type symbol that was declared. Given a namespace declaration, get the corresponding type symbol. The syntax node that declares a namespace. The namespace symbol that was declared. Given a method, property, or event declaration, get the corresponding symbol. The syntax node that declares a method, property, or event. The method, property, or event symbol that was declared. Given a parameter declaration, get the corresponding parameter symbol. The syntax node that declares a parameter. The parameter symbol that was declared. Given an import clause get the corresponding symbol for the import alias that was introduced. The import statement syntax node. The alias symbol that was declared or Nothing if no alias symbol was declared. Given a type parameter declaration, get the corresponding type parameter symbol. The syntax node that declares a type parameter. The type parameter symbol that was declared. Gets the semantic information of a for each statement. The for each syntax node. The SyntaxTree that is bound Get the correct enclosing binder for the given position, taking into account block constructs and lambdas. Binder for the method body, lambda body, or field initializer. The returned binder will be nested inside the binder, or be this binder. Syntax node that is the root of the construct associated with "memberBinder". Syntax node that position is in. Position we are finding the enclosing binder for. The enclosing binder within "memberBinder" for the given position. WARN WARN WARN: The result is not guaranteed to have IsSemanticModelBinder set. If answer is True, the binder is returned via [binder] parameter. If answer is True, the binder is returned via [binder] parameter. Get all bound nodes associated with a node, ordered from highest to lowest in the bound tree. Strictly speaking, the order is that of a pre-order traversal of the bound tree. As a side effect, caches nodes and binders. A collection initializer syntax node is not always treated as a VB expression syntax node in case it's part of a CollectionInitializer (outer most or top level initializer). The syntax node to check. True if the syntax node represents an expression syntax, but it's not an expression from the VB language point of view; otherwise False. Incrementally bind bindingRoot (which is always a non-lambda enclosed statement, or the root of this model). Side effect is to store nodes into the guarded node map. In order that any expression level special binders are used, lambdas are fully resolved, and that any other binding context is correctly handled, we only use the binder to create bound nodes for: a) The root syntax of this semantic model (because there's nothing more outer to bind) b) A stand-alone statement is that is not inside a lambda. The incremental binder is used when binding statements. Whenever a statement is bound, it checks the bound node cache to see if that statement was bound, and returns it instead of rebinding it. FOr example, we might have: While x > goo() y = y * x z = z + y End While We might first get semantic info about "z", and thus bind just the statement "z = z + y". Later, we might bind the entire While block. While binding the while block, we can reuse the binding we did of "z = z + y". We override GetBinder so that the BindStatement override is still in effect on nested binders. We override GetBinder so that the BindStatement override is still in effect on nested binders. Traverse a tree of bound nodes, and update the following maps inside the SemanticModel: guardedNodeMap - a map from syntax node to bound nodes. Bound nodes are added in the order they are bound traversing the tree, so they will be in order from upper to lower node. guardedQueryBindersMap - a map from query-specific syntax node to an array of binders used to bind various children of the node. guardedAnonymousTypeBinderMap - a map from Anonymous Type initializer's FieldInitializerSyntax to Binder.AnonymousTypeFieldInitializerBinder used to bind its expression. Should we record bound node mapping for this node? Generally, we ignore compiler generated, but optionally can allow. Provides context for binding body of a MethodSymbol. Create binder for binding the body of a method. Creates a MethodBodySemanticModel that allows asking semantic questions about an attribute node. Creates a speculative semantic model that allows asking semantic questions about an attribute node that did not appear in the original source code. A MethodTypeParametersBinder provides the context for looking up type parameters on a method. It is split out since binding of type in the parameters and return value need to happen with a context that includes the type parameters, but we don't have a fully complete method symbol yet. Looks up the name in the type parameters a) type parameters in this type (but not outer or base types) Returns all members of that name, or empty list if none. A NamedTypeBinder provides the context for a type symbol; e.g., looking up names inside the type. Some nodes have special binder's for their contents Gets all symbols of the particular name as a) members of this type b) members of base types c) type parameters in this type (but not outer or base types) In that order. Note, that section "11.4.4 Simple Name Expression" of VB Language spec implies that type parameters are examined first, and only then members of the type are examined. But this is inconsistent with Dev10 behavior. Returns all members of that name, or empty list if none. Collect extension methods with the given name that are in scope in this binder. The passed in ArrayBuilder must be empty. Extension methods from the same containing type must be grouped together. A namespace binder provides the context for a namespace symbol; e.g., looking up names inside the namespace. Collect extension methods with the given name that are in scope in this binder. The passed in ArrayBuilder must be empty. Extension methods from the same containing type must be grouped together. A ProjectImportsBinder provides the equivalent of a SourceFileBinder, but for the project-level imports, which don't live in any file. It primarily provides the services of getting locations of nodes, since it holds onto a SyntaxTree, although that tree isn't technically a source tree. Returns True for A SourceFileBinder provides the context associated with a give source file, not including the Imports statements (which have their own binders). It primarily provides the services of getting locations of node, since it holds onto a SyntaxTree. A source module binder provides the context associated with a source module. Binder used for speculatively binding. Allows asking semantic questions about a TypeSyntax or RangeArgumentSyntax node within a member, that did not appear in the original source code. Typically, an instance is obtained by a call to SemanticModel.TryGetSpeculativeSemanticModel. Creates a speculative SemanticModel for a TypeSyntax or a RangeArgumentSyntax node at a position within an existing MemberSemanticModel. Provides context for binding statements in speculative code. Create binder for binding statements in speculative code. A SubOrFunctionBodyBinder provides context for looking up parameters/labels in a body of an executable entity (a method, lambda, or top-level script code), and also for the implementation of ContainingMember, GetLocalForFunctionValue and GetBinder. This is used while computing the values of constant symbols. Since they can depend on each other, we need to keep track of which ones we are currently computing in order to avoid (and report) cycles. Manages anonymous types and delegates created on module level. All requests for anonymous type/delegate symbols go via the instance of this class. Manager also is in charge of creating implementation types which are used in emit phase to substitute anonymous type/delegate public symbols. Builds a condition in the following form: [preaction: localMyFieldBoxed = DirectCast(Me.field, System.Object)] [preaction: localOtherFieldBoxed = DirectCast(Other.field, System.Object)] IF(localMyFieldBoxed IsNot Nothing AndAlso localOtherFieldBoxed IsNot Nothing, localMyFieldBoxed.Equals(localOtherFieldBoxed), localMyFieldBoxed Is localOtherFieldBoxed ) Source module Owning compilationSource module Given anonymous type descriptor provided construct an anonymous type symbol Given anonymous delegate descriptor provided, construct an anonymous delegate symbol Cache of created anonymous types Cache of created anonymous delegates Given anonymous type public symbol construct an anonymous type symbol to be used in emit; the type symbol is created based on generic type generated for each 'unique' anonymous type structure. Given anonymous delegate public symbol construct an anonymous type symbol to be used in emit; the type symbol may be created based on generic type generated for each 'unique' anonymous delegate structure OR if the delegate's signature is 'Sub()' it will be an instance of NonGenericAnonymousDelegateSymbol type. Resets numbering in anonymous type names and compiles the anonymous type methods. Also seals the collection of templates. Translates anonymous type public symbol into an implementation type symbol to be used in emit. Translates anonymous type method symbol into an implementation method symbol to be used in emit. Returns all templates owned by this type manager Checks if all special and well-known symbols required for emitting anonymous types provided exist, if not reports errors and returns True. Force all declaration errors to be generated. Map an anonymous type or delegate public symbol to an implementation symbol to be used in emit. NOTE: All anonymous types/delegated (except for delegate with signature 'Sub()') with the same set of fields/parameters (field names and IsKey flags are taken into account) are generated based on the same generic type template. Map an anonymous type or delegate's method symbol to an implementation method symbol to be used in emit Map an anonymous type or delegate's method symbol to a substituted method symbol. Index of the property in the containing anonymous type This is a symbol to represent Anonymous Delegate for a lambda like: Sub() ... This delegate type doesn't have generic parameters. Unlike generic anonymous types, for which we are constructing new instance of substituted symbol for each use site with reference to the location, we are creating new instance of this symbol with its own location for each use site. But all of them are representing the same delegate type and are going to be equal to each other. The name used to emit definition of the type. Will be set when the type's metadata is ready to be emitted, Name property will throw exception if this field is queried before that moment because the name is not defined yet. The key of the anonymous type descriptor used for this type template Describes the type descriptor location and property/parameter names associated with this location In emit phase every time a created anonymous type is referenced we try to adjust name of template's fields as well as store the lowest location of the template. The last one will be used for ordering templates and assigning emitted type names. Force all declaration errors to be generated. Index of the property in the containing anonymous type This class represents a compiler generated parameterless constructor Initializes a new instance of the class. The containing type for the synthesized constructor. if set to true if this is a shared constructor. if set to true if this constructor will include debuggable initializers. Binder to be used for error reporting, or Nothing. Diagnostic bag, or Nothing. The parameters forming part of this signature. This class represents a simple customizable hash method to hash the string constants corresponding to the case clause string constants. If we have at least one string type select case statement in a module that needs a hash table based jump table, we generate a single public string hash synthesized method (SynthesizedStringSwitchHashMethod) that is shared across the module. We must emit this function into the compiler generated PrivateImplementationDetails class. Compute the hashcode of a sub string using FNV-1a See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function This method should be kept consistent with MethodBodySynthesizer.ConstructStringSwitchHashFunctionBody The control flow in this method mimics lowered "for" loop. It is exactly what we want to emit to ensure that JIT can do range check hoisting. Construct a body for String Switch Hash Function This method should be kept consistent with ComputeStringHash The parameters forming part of this signature. A Declaration summarizes the declaration structure of a source file. Each entity declaration in the program that is a container (specifically namespaces, classes, interfaces, structs, and delegate declarations) is represented by a node in this tree. At the top level, the compilation unit is treated as a declaration of the unnamed namespace. Special treatment is required for namespace declarations, because a single namespace declaration can declare more than one namespace. For example, in the declaration namespace A.B.C {} we see that namespaces A and B and C are declared. This declaration is represented as three declarations. All three of these ContainerDeclaration objects contain a reference to the syntax tree for the declaration. A "single" declaration represents a specific namespace or type declaration at a point in source code. A "root" declaration is a special single declaration which summarizes the contents of an entire file's types and namespaces. Each source file is represented as a tree of single declarations. A "merged" declaration merges together one or more declarations for the same symbol. For example, the root namespace has multiple single declarations (one in each source file) but there is a single merged declaration for them all. Similarly partial classes may have multiple declarations, grouped together under the umbrella of a merged declaration. In the common trivial case, a merged declaration for a single declaration contains only that single declaration. The whole program, consisting of the set of all declarations in all of the source files, is represented by a tree of merged declarations.''' A declaration table is a device which keeps track of type and namespace declarations from parse trees. It is optimized for the case where there is one set of declarations that stays constant, and a specific root namespace declaration corresponding to the currently edited file which is being added and removed repeatedly. It maintains a cache of information for "merging" the root declarations into one big summary declaration; this cache is efficiently re-used provided that the pattern of adds and removes is as we expect. A wrapper around RootSingleNamespaceDeclaration. The namespace declaration is evaluated lazily to avoid evaluating the namespace and associated SyntaxTree for embedded syntax trees before we can determine whether the syntax tree is needed. Pool of builders used to create our member name sets. Importantly, these use so that name lookup happens in an appropriate manner for VB identifiers. This allows fast member name O(log(n)) even if the casing doesn't match. Represents global namespace. Namespace's name is always empty This function is used to determine the best name of a type or namespace when there are multiple declarations that have the same name but with different spellings. If this declaration is part of the rootnamespace (specified by /rootnamespace:<nsname> this is considered the best name. Otherwise the best name of a type or namespace is the one that String.Compare considers to be less using a Ordinal. In practice this prefers uppercased or camelcased identifiers. The single declarations. Set to true if there were multiple distinct spellings. This function is used to determine the best name of a type or namespace when there are multiple declarations that have the same name but with different spellings. If this declaration is part of the rootnamespace (specified by /rootnamespace:<nsname> this is considered the best name. Otherwise the best name of a type or namespace is the one that String.Compare considers to be less using a Ordinal. In practice this prefers uppercased or camelcased identifiers. The single declarations. Set to true if there were multiple distinct spellings. An ArrayTypeSymbol represents an array type, such as Integer() or Object(,). Create a new ArrayTypeSymbol. Create a new ArrayTypeSymbol. Returns the list of custom modifiers, if any, associated with the array. Returns the number of dimensions of this array. A regular single-dimensional array has rank 1, a two-dimensional array has rank 2, etc. Is this a zero-based one-dimensional array, i.e. SZArray in CLR terms. Specified sizes for dimensions, by position. The length can be less than , meaning that some trailing dimensions don't have the size specified. The most common case is none of the dimensions have the size specified - an empty array is returned. Specified lower bounds for dimensions, by position. The length can be less than , meaning that some trailing dimensions don't have the lower bound specified. The most common case is all dimensions are zero bound - a default (Nothing) array is returned in this case. Note, equality should be checked separately!!! Normally VB arrays have default sizes and lower bounds - sizes are not specified and all dimensions are zero bound. This property should return false for any deviations. Returns the type of the elements that are stored in this array. Returns true if this type is known to be a reference type. It is never the case that and both return true. However, for an unconstrained type parameter, and will both return false. True Returns true if this type is known to be a value type. It is never the case that and both return true. However, for an unconstrained type parameter, and will both return false. False Get all the members of this symbol. An ImmutableArray containing all the members of this symbol. If this symbol has no members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that have a particular name. An ImmutableArray containing all the members of this symbol with the given name. If there are no members with this name, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types. An ImmutableArray containing all the types that are members of this symbol. If this symbol has no type members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types that have a particular name, and any arity. An ImmutableArray containing all the types that are members of this symbol with the given name. If this symbol has no type members with this name, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types that have a particular name and arity. An ImmutableArray containing all the types that are members of this symbol with the given name and arity. If this symbol has no type members with this name and arity, returns an empty ImmutableArray. Never returns Nothing. Returns of the symbol. Returns of the symbol. Get the symbol that logically contains this symbol. Nothing Gets the locations where this symbol was originally defined, either in source or metadata. Some symbols (for example, partial classes) may be defined in more than one location. Get the syntax node(s) where this symbol was declared in source. An empty read-only array. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Represents SZARRAY - zero-based one-dimensional array Represents MDARRAY - multi-dimensional array (possibly of rank 1) Represents an attribute applied to a Symbol. Gets the attribute class being applied. Gets the constructor used in this application of the attribute. Gets a reference to the source for this application of the attribute. Returns null for applications of attributes on metadata Symbols. Gets the list of constructor arguments specified by this application of the attribute. This list contains both positional arguments and named arguments that are formal parameters to the constructor. Gets the list of named field or property value arguments specified by this application of the attribute. Compares the namespace and type name with the attribute's namespace and type name. Returns true if they are the same. Checks if an applied attribute with the given attributeType matches the namespace name and type name of the given early attribute's description and the attribute description has a signature with parameter count equal to the given attribute syntax's argument list count. NOTE: We don't allow early decoded attributes to have optional parameters. Returns the that represents the current AttributeData. A that represents the current AttributeData. Gets the attribute class being applied as an Gets the constructor used in this application of the attribute as an . Gets a reference to the source for this application of the attribute. Returns null for applications of attributes on metadata Symbols. Decodes PermissionSetAttribute applied in source to determine if it needs any fixup during codegen. PermissionSetAttribute needs fixup when it contains an assignment to the 'File' property as a single named attribute argument. Fixup performed is ported from SecurityAttributes::FixUpPermissionSetAttribute. It involves following steps: 1) Verifying that the specified file name resolves to a valid path. 2) Reading the contents of the file into a byte array. 3) Convert each byte in the file content into two bytes containing hexa-decimal characters. 4) Replacing the 'File = fileName' named argument with 'Hex = hexFileContent' argument, where hexFileContent is the converted output from step 3) above. Step 1) is performed in this method, i.e. during binding. Remaining steps are performed during serialization as we want to avoid retaining the entire file contents throughout the binding/codegen pass. See for remaining fixup steps. String containing the resolved file path if PermissionSetAttribute needs fixup during codegen, null otherwise. This method determines if an applied attribute must be emitted. Some attributes appear in symbol model to reflect the source code, but should not be emitted. Represents a custom modifier (modopt/modreq). A type used as a tag that indicates which type of modification applies. Represents an event. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. True if the event itself Is excluded from code coverage instrumentation. True for source events marked with . True if this symbol has a special name (metadata flag SpecialName is set). Gets the attributes on event's associated field, if any. Returns an array of or an empty array if there are no attributes. Backing field of the event, or Nothing if the event doesn't have any. Events imported from metadata return Nothing. Gets the parameters of this event. If this event has no parameters, returns an empty list. Gets the return type of the event (typically System.Void). Can be null in error cases. Implements visitor pattern. Is this an event of a tuple type? If this is an event of a tuple type, return corresponding underlying event from the tuple underlying type. Otherwise, Nothing. Represents a member variable -- a variable declared as a member of a Class or Structure. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Gets the type of this variable. Gets a value indicating whether this instance has declared type. This means a field was declared with an AsClause or in case of const fields with an AsClause whose type is not System.Object true if this instance has declared type; otherwise, false. The list of custom modifiers, if any, associated with the member variable. If this variable serves as a backing variable for an automatically generated property or event, returns that property or event. Otherwise returns Nothing. Note, the set of possible associated symbols might be expanded in the future to reflect changes in the languages. Returns true if this variable was declared as ReadOnly Returns true if this field was declared as "const" (i.e. is a constant declaration), or is an Enum member. Gets a value indicating whether this instance is metadata constant. A field is considered to be metadata constant if the field value is a valid default value for a field. true if this instance is metadata constant; otherwise, false. Gets a value indicating whether this instance is const, but not metadata constant. A field is considered to be const but not metadata constant if the const field's type is either Date or Decimal. true if this instance is metadata constant; otherwise, false. Returns false if the field wasn't declared as "const", or constant value was omitted or erroneous. True otherwise. If IsConst returns true, then returns the value of the constant or Enum member. If IsConst return false, then returns Nothing. Gets the constant value. Used to detect dependencies between constant field values. Const fields do not (always) have to be declared with a given type. To get the inferred type determined from the initialization this method should be called instead of "Type". For non const field this method returns the declared type. Used to detect dependencies between constant field values. True if this symbol has a special name (metadata flag SpecialName is set). True if RuntimeSpecialName metadata flag is set for this symbol. True if NotSerialized metadata flag is set for this symbol. Describes how the field is marshalled when passed to native code. Null if no specific marshalling information is available for the field. PE symbols don't provide this information and always return Nothing. Returns the marshalling type of this field, or 0 if marshalling information isn't available. By default this information is extracted from if available. Since the compiler does only need to know the marshalling type of symbols that aren't emitted PE symbols just decode the type from metadata and don't provide full marshalling information. Offset assigned to the field when the containing type is laid out by the VM. Nothing if unspecified. Get the "this" parameter for this field. This is only valid for source fields. Returns true when field is a backing field for a captured frame pointer (typically "Me"). Return error code that has highest priority while calculating use site error for this symbol. Is this a field of a tuple type? Returns True when field symbol is not mapped directly to a field in the underlying tuple struct. Returns true if this is a field representing a Default element like Item1, Item2... If this is a field of a tuple type, return corresponding underlying field from the tuple underlying type. Otherwise, Nothing. In case of a malformed underlying type the corresponding underlying field might be missing, return Nothing in this case too. If this field represents a tuple element, returns a corresponding default element field. Otherwise returns Nothing If this is a field representing a tuple element, returns the index of the element (zero-based). Otherwise returns -1 Returns the RefKind of the field. Custom modifiers associated with the ref modifier, or an empty array if there are none. This method indicates whether or not the runtime will regard the method as newslot (as indicated by the presence of the "newslot" modifier in the signature). WARN WARN WARN: We won't have a final value for this until declaration diagnostics have been computed for all s, so pass ignoringInterfaceImplementationChanges: True if you need a value sooner and aren't concerned about tweaks made to satisfy interface implementation requirements. NOTE: Not ignoring changes can only result in a value that is more true. Gets what kind of method this is. There are several different kinds of things in the VB language that are represented as methods. This property allow distinguishing those things without having to decode the name of the method. True, if the method kind was determined by examining a syntax node (i.e. for source methods - including substituted and retargeted ones); false, otherwise. Returns whether this method is using VARARG calling convention. Returns whether this built-in operator checks for integer overflow. Returns whether this method is generic; i.e., does it have any type parameters? Returns the arity of this method, or the number of type parameters it takes. A non-generic method has zero arity. Get the type parameters on this method. If the method has not generic, returns an empty list. Returns the type arguments that have been substituted for the type parameters. If nothing has been substituted for a given type parameter, then the type parameter itself is consider the type argument. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Returns the method symbol that this method was constructed from. This method symbol has the same containing type (if any), but has type arguments that are the same as the type parameters (although its containing type might not). Always returns false because the 'readonly members' feature is not available in VB. Returns true if this method has no return type; i.e., is a Sub instead of a Function. Source: Returns whether this method is async; i.e., does it have the Async modifier? Metadata: Returns False; methods from metadata cannot be async. Source: Returns whether this method is an iterator; i.e., does it have the Iterator modifier? Metadata: Returns False; methods from metadata cannot be an iterator. Indicates whether the accessor is marked with the 'init' modifier. Source: Returns False; methods from source cannot return by reference. Metadata: Returns whether or not this method returns by reference. Gets the return type of the method. If the method is a Sub, returns the same type symbol as is returned by Compilation.VoidType. Returns the list of custom modifiers, if any, associated with the returned value. Custom modifiers associated with the ref modifier, or an empty array if there are none. Returns the list of attributes, if any, associated with the return type. Build and add synthesized return type attributes for this method symbol. Optimization: in many cases, the parameter count (fast) is sufficient and we don't need the actual parameter symbols (slow). The default implementation is always correct, but may be unnecessarily slow. Gets the parameters of this method. If this method has no parameters, returns an empty list. Should return syntax node that originated the method. Returns true if calls to this method are omitted in the given syntax tree at the given syntax node location. Calls are omitted when the called method is a partial method with no implementation part, or when the called method is a conditional method whose condition is not true at the given syntax node location in the source file corresponding to the given syntax tree. Calls are conditionally omitted if all the following requirements are true: (a) Me.IsSub == True. (b) Containing type is not an interface type. (c) Me.IsConditional == True, i.e. it has at least one applied conditional attribute. (d) This method is not the Property Set method. (e) None of conditional symbols corresponding to these conditional attributes are true at the given syntax node location. Forces binding and decoding of attributes. Returns a sequence of preprocessor symbols specified in applied on this symbol, or null if there are none. Returns a flag indicating whether this symbol has at least one applied conditional attribute. Forces binding and decoding of attributes. NOTE: Conditional symbols on the overridden method must be inherited by the overriding method, but the native VB compiler doesn't do so. We maintain compatibility. True if the method itself Is excluded from code coverage instrumentation. True for source methods marked with . True if this symbol has a special name (metadata flag SpecialName is set). This is set for methods with special semantics such as constructors or accessors as well as in special synthetic methods such as lambdas. Also set for methods marked with System.Runtime.CompilerServices.SpecialNameAttribute. If this method has MethodKind of MethodKind.PropertyGet or MethodKind.PropertySet, returns the property that this method is the getter or setter for. If this method has MethodKind of MethodKind.EventAdd or MethodKind.EventRemove, returns the event that this method is the adder or remover for. Note, the set of possible associated symbols might be expanded in the future to reflect changes in the languages. If this method is a Lambda method (MethodKind = MethodKind.LambdaMethod) and there is an anonymous delegate associated with it, returns this delegate. Returns Nothing if the symbol is not a lambda or if it does not have an anonymous delegate associated with it. If this method overrides another method (because it both had the Overrides modifier and there correctly was a method to override), returns the overridden method. Returns interface methods explicitly implemented by this method. Returns true if this method is not implemented in IL of the assembly it is defined in. External methods are 1) Declare Subs and Declare Functions, 2) methods marked by , 3) methods marked by with or flags. 4) Synthesized constructors of ComImport types Returns platform invocation information for this method if it is a PlatformInvoke method, otherwise returns Nothing. Marshalling information for return value (FieldMarshal in metadata). Misc implementation metadata flags (ImplFlags in metadata). Declaration security information associated with this method, or null if there is none. True if the method has declarative security information (HasSecurity flags). True if the method calls another method containing security code (metadata flag RequiresSecurityObject is set). Returns true if this method is an extension method from the VB language perspective; i.e., declared with an Extension attribute and meets other language requirements. Returns true if this method might be a reducible extension method. This method may return true even if the method is not an extension method, but if it returns false, it must be the case that this is not an extension method. Allows checking extension methods from source in a quicker manner than fully binding attributes. Returns true if this method hides a base method by name and signature. The equivalent of the "hidebysig" flag in metadata. This property should not be confused with general method overloading in Visual Basic, and is not directly related. This property will only return true if this method hides a base method by name and signature (Overloads keyword). Gets the resolution priority of this method, 0 if not set. Do not call this method from early attribute binding, cycles will occur. True if the implementation of this method is supplied by the runtime. implies . Determines whether this method is a candidate for a default assembly entry point. Any method called "Main" is. True if the method can be used as an entry point. Entry point is considered accessible if it is not private and none of the containing types is private (they all might be Family or Friend). Checks if the method has an entry point compatible signature, i.e. - the return type is either void or int - has either no parameter or a single parameter of type string[] Checks for validity of Construct(...) on this method with these type arguments. Call and throw if it returns false. True if this type supports retrieving the Me parameter and false otherwise. Note that a return value of true does not guarantee a non-Nothing (e.g. fails for shared methods). Return error code that has highest priority while calculating use site error for this symbol. If this method is a reduced extension method, gets the extension method definition that this method was reduced from. Otherwise, returns Nothing. Is this a reduced extension method? If this method is a reduced extension method, gets the extension method (possibly constructed) that should be used at call site during ILGen. Otherwise, returns Nothing. If this method can be applied to an object, returns the type of object it is applied to. If this method is a reduced extension method, returns a type inferred during reduction process for the type parameter. Type parameter of the corresponding method. Inferred type or Nothing if nothing was inferred. If this is not a reduced extension method. If is Nothing. If doesn't belong to the corresponding method. Fixed type parameters for a reduced extension method or empty. If this is an extension method that can be applied to a instance of the given type, returns the reduced method symbol thus formed. Otherwise, returns Nothing. Name lookup should use this method in order to capture proximity, which affects overload resolution. If this is an extension method that can be applied to a instance of the given type, returns the reduced method symbol thus formed. Otherwise, returns Nothing. Proximity level of a reduced extension method. Returns bound block representing method's body. This method is called by 'method compiler' when it is ready to emit IL code for the method. The bound method body is typically a high-level tree - it may contain lambdas, foreach etc... which will be processed in CompileMethod(...) Enables synthesized methods to create instances. Optionally returns a binder, OUT parameter! The method MAY return a binder used for binding so it can be reused later in method compiler True iff the method contains user code. Calculates a syntax offset for a local (user-defined or long-lived synthesized) declared at . Must be implemented by all methods that may contain user code. Syntax offset is a unique identifier for the local within the emitted method body. It's based on position of the local declarator. In single-part method bodies it's simply the distance from the start of the method body syntax span. If a method body has multiple parts (such as a constructor comprising of code for member initializers and constructor initializer calls) the offset is calculated as if all source these parts were concatenated together and prepended to the constructor body. The resulting syntax offset is then negative for locals defined outside of the constructor body. Specifies whether existing, "unused" locals (corresponding to proxies) are preserved during lambda rewriting. This value will be checked by the and is needed so that existing locals aren't omitted in the EE (method symbols in the EE will override this property to return True). Is this a method of a tuple type? If this is a method of a tuple type, return corresponding underlying method from the tuple underlying type. Otherwise, Nothing. Returns true if this symbol is defined outside of the compilation. For instance if the method is Declare Sub. If this is a partial method declaration without a body, and the method also has a part that implements it with a body, returns that implementing definition. Otherwise null. If this is a partial method with a body, returns the corresponding definition part (without a body). Otherwise null. Represents a type other than an array, a type parameter. Should return Nothing if there are none. if uninitialized. if there are errors. if there are no required members. Otherwise, the required members. Returns the arity of this type, or the number of type parameters it takes. A non-generic type has zero arity. Returns the type parameters that this type has. If this is a non-generic type, returns an empty ImmutableArray. Returns custom modifiers for the type argument that has been substituted for the type parameter. The modifiers correspond to the type argument at the same ordinal within the array. Returns the type arguments that have been substituted for the type parameters. If nothing has been substituted for a given type parameter, then the type parameter itself is consider the type argument. Returns the type symbol that this type was constructed from. This type symbol has the same containing type, but has type arguments that are the same as the type parameters (although its containing type might not). For enum types, gets the underlying type. Returns null on all other kinds of types. For implicitly declared delegate types returns the EventSymbol that caused this delegate type to be generated. For all other types returns null. Note, the set of possible associated symbols might be expanded in the future to reflect changes in the languages. Returns True for one of the types from a set of Structure types if that set represents a cycle. This property is intended for flow analysis only since it is only implemented for source types, and only returns True for one of the types within a cycle, not all. Is this a NoPia local type explicitly declared in source, i.e. top level type with a TypeIdentifier attribute on it? Returns true and a string from the first GuidAttribute on the type, the string might be null or an invalid guid representation. False, if there is no GuidAttribute with string argument. True if the type itself Is excluded from code coverage instrumentation. True for source types marked with . Should the name returned by Name property be mangled with [`arity] suffix in order to get metadata name. Must return False for a type with Arity == 0. Default implementation to force consideration of appropriate implementation for each new subclass True if this symbol has a special name (metadata flag SpecialName is set). True if this type is considered serializable (metadata flag Serializable is set). Type layout information (ClassLayout metadata and layout kind flags). The default charset used for type marshalling. Can be changed via applied on the containing module. Marshalling charset of string data fields within the type (string formatting flags in metadata). For delegate types, gets the delegate's invoke method. Returns null on all other kinds of types. Note that it is possible to have an ill-formed delegate type imported from metadata which does not have an Invoke method. Such a type will be classified as a delegate but its DelegateInvokeMethod would be null. Returns true if this type was declared as requiring a derived class; i.e., declared with the "MustInherit" modifier. Always true for interfaces. Returns true if this type does not allow derived types; i.e., declared with the NotInheritable modifier, or else declared as a Module, Structure, Enum, or Delegate. If this property returns false, it is certain that there are no extension methods inside this type. If this property returns true, it is highly likely (but not certain) that this type contains extension methods. This property allows the search for extension methods to be narrowed much more quickly. !!! Note that this property can mutate during lifetime of the symbol !!! !!! from True to False, as we learn more about the type. !!! Returns True if the type is marked by 'Microsoft.CodeAnalysis.Embedded' attribute. Returns True if the type is marked by 'Microsoft.VisualBasic.Embedded' attribute. A Named type is an extensible interface if both the following are true: (a) It is an interface type and (b) It is either marked with 'TypeLibTypeAttribute( flags w/o TypeLibTypeFlags.FNonExtensible )' attribute OR is marked with 'InterfaceTypeAttribute( flags with ComInterfaceType.InterfaceIsIDispatch )' attribute OR inherits from an extensible interface type. Member resolution for Extensible interfaces is late bound, i.e. members are resolved at run time by looking up the identifier on the actual run-time type of the expression. This method is an entry point for the Binder to collect extension methods with the given name declared within this named type. Overridden by RetargetingNamedTypeSymbol. This method is called for a type within a namespace when we are building a map of extension methods for the whole (compilation merged or module level) namespace. The 'appendThrough' parameter allows RetargetingNamespaceSymbol to delegate majority of the work to the underlying named type symbols, but still add RetargetingMethodSymbols to the map. This is an entry point for the Binder. Its purpose is to add names of viable extension methods declared in this type to nameSet parameter. Add names of viable extension methods declared in this type to nameSet parameter. The 'appendThrough' parameter allows RetargetingNamedTypeSymbol to delegate majority of the work to the underlying named type symbol, but still perform viability check on RetargetingMethodSymbol. Get the instance constructors for this type. Get the shared constructors for this type. Get the instance and shared constructors for this type. Returns true if this type is known to be a reference type. It is never the case that IsReferenceType and IsValueType both return true. However, for an unconstrained type parameter, IsReferenceType and IsValueType will both return false. Returns true if this type is known to be a value type. It is never the case that IsReferenceType and IsValueType both return true. However, for an unconstrained type parameter, IsReferenceType and IsValueType will both return false. Returns True if this types has Arity >= 1 and Construct can be called. This is primarily useful when deal with error cases. Returns a constructed type given its type arguments. Returns a constructed type given its type arguments. Construct a new type from this type, substituting the given type arguments for the type parameters. This method should only be called if this named type does not have any substitutions applied for its own type arguments with exception of alpha-rename substitution (although it's container might have substitutions applied). A set of type arguments to be applied. Must have the same length as the number of type parameters that this type has. Checks for validity of Construct(...) on this type with these type arguments. Construct a new type from this type definition, substituting the given type arguments for the type parameters. This method should only be called on the OriginalDefinition. Unlike previous Construct method, this overload supports type parameter substitution on this type and any number of its containing types. See comments for TypeSubstitution type for more information. Returns an unbound generic type of this generic named type. Returns Default property name for the type. If there is no default property name, then Nothing is returned. If this is a generic type instantiation or a nested type of a generic type instantiation, return TypeSubstitution for this construction. Nothing otherwise. Returned TypeSubstitution should target OriginalDefinition of the symbol. Gets the name of this symbol. Collection of names of members declared within this type. Returns true if the type is a Script class. It might be an interactive submission class or a Script class in a csx file. Returns true if the type is a submission class. Returns true if the type is the implicit class that holds onto invalid global members (like methods or statements in a non script file). Get all the members of this symbol. An ImmutableArray containing all the members of this symbol. If this symbol has no members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that have a particular name. An ImmutableArray containing all the members of this symbol with the given name. If there are no members with this name, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types. An ImmutableArray containing all the types that are members of this symbol. If this symbol has no type members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types that have a particular name, and any arity. An ImmutableArray containing all the types that are members of this symbol with the given name. If this symbol has no type members with this name, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types that have a particular name and arity. An ImmutableArray containing all the types that are members of this symbol with the given name and arity. If this symbol has no type members with this name and arity, returns an empty ImmutableArray. Never returns Nothing. Get this accessibility that was declared on this symbol. For symbols that do not have accessibility declared on them, returns NotApplicable. Supports visitor pattern. Gets the kind of this symbol. Returns a flag indicating whether this symbol is ComImport. A type can me marked as a ComImport type in source by applying the If CoClassAttribute was applied to the type returns the type symbol for the argument. Type symbol may be an error type if the type was not found. Otherwise returns Nothing Returns a sequence of preprocessor symbols specified in applied on this symbol, or null if there are none. Returns a flag indicating whether this symbol has at least one applied conditional attribute. Forces binding and decoding of attributes. NOTE: Conditional symbols on base type must be inherited by derived type, but the native VB compiler doesn't do so. We maintain compatibility. Gets the associated for an attribute type. Declaration security information associated with this type, or null if there is none. True if the type has declarative security information (HasSecurity flags). NamedTypeSymbol calls derived implementations of this method when declared base type is needed for the first time. basesBeingResolved are passed if there are any types already have their bases resolved so that the derived implementation could avoid infinite recursion NamedTypeSymbol calls derived implementations of this method when declared interfaces are needed for the first time. basesBeingResolved are passed if there are any types already have their bases resolved so that the derived implementation could avoid infinite recursion Base type as "declared". Declared base type may contain circularities. If DeclaredBase must be accessed while other DeclaredBases are being resolved, the bases that are being resolved must be specified here to prevent potential infinite recursion. Interfaces as "declared". Declared interfaces may contain circularities. If DeclaredInterfaces must be accessed while other DeclaredInterfaces are being resolved, the bases that are being resolved must be specified here to prevent potential infinite recursion. NamedTypeSymbol calls derived implementations of this method when acyclic base type is needed for the first time. This method typically calls GetDeclaredBase, filters for illegal cycles and other conditions before returning result as acyclic. NamedTypeSymbol calls derived implementations of this method when acyclic base interfaces are needed for the first time. This method typically calls GetDeclaredInterfaces, filters for illegal cycles and other conditions before returning result as acyclic. Base type. Could be Nothing for Interfaces or Object. Interfaces that are implemented or inherited (if current type is interface itself). Returns declared base type or actual base type if already known This is only used by cycle detection code so that it can observe when cycles are broken while not forcing actual Base to be realized. Returns declared interfaces or actual Interfaces if already known This is only used by cycle detection code so that it can observe when cycles are broken while not forcing actual Interfaces to be realized. True if and only if this type or some containing type has type parameters. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Should return full emitted namespace name for a top level type if the name might be different in case from containing namespace symbol full name, Nothing otherwise. Does this type implement all the members of the given interface. Does not include members of interfaces that iface inherits, only direct members. True if this is a reference to an unbound generic type. These occur only within a GetType expression. A generic type is considered unbound if all of the type argument lists in its fully qualified name are empty. Note that the type arguments of an unbound generic type will be returned as error types because they do not really have type arguments. An unbound generic type yields null for its BaseType and an empty result for its Interfaces. Force all declaration errors to be generated. Return compiler generated nested types that are created at Declare phase, but not exposed through GetMembers and the like APIs. Should return Nothing if there are no such types. True if the type is a Windows runtime type. A type can me marked as a Windows runtime type in source by applying the WindowsRuntimeImportAttribute. WindowsRuntimeImportAttribute is a pseudo custom attribute defined as an internal class in System.Runtime.InteropServices.WindowsRuntime namespace. This is needed to mark Windows runtime types which are redefined in mscorlib.dll and System.Runtime.WindowsRuntime.dll. These two assemblies are special as they implement the CLR's support for WinRT. True if the type should have its WinRT interfaces projected onto .NET types and have missing .NET interface members added to the type. Requires less computation than == . Metadata types need to compute their base types in order to know their TypeKinds, And that can lead to cycles if base types are already being computed. True if this Is an interface type. Get synthesized WithEvents overrides that aren't returned by Gets all of the required members from this type and all base types. This will be a set of the most derived overrides. If is true, this will be . True if this or any base type has a required members error, and constructors should be blocked unless attributed with SetsRequiredMembersAttribute. When this is true, will be is simple for most named types: enums are not managed; non-enum, non-struct named types are managed; type parameters are managed unless an 'unmanaged' constraint is present; all special types have spec'd values (basically, (non-string) primitives) are not managed; Only structs are complicated, because the definition is recursive. A struct type is managed if one of its instance fields is managed or a ref field. Unfortunately, this can result in infinite recursion. If the closure is finite, and we don't find anything definitely managed, then we return true. If the closure is infinite, we disregard all but a representative of any expanding cycle. Intuitively, this will only return true if there's a specific type we can point to that is would be managed even if it had no fields. e.g. struct S { S s; } is not managed, but struct S { S s; object o; } is because we can point to object. Verify if the given type can be used to back a tuple type and return cardinality of that tuple type in . If method returns true, contains cardinality of the compatible tuple type. Represents a namespace. Get all the members of this symbol that are namespaces. An ImmutableArray containing all the namespaces that are members of this symbol. If this symbol has no namespace members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are modules. An ImmutableArray containing all the types that are members of this namespace. If this namespace has no module members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are modules that have a particular name An ImmutableArray containing all the modules that are members of this namespace with the given name. If this symbol has no modules with this name, returns an empty ImmutableArray. Never returns Nothing. Returns whether this namespace is the unnamed, global namespace that is at the root of all namespaces. The kind of namespace: Module, Assembly or Compilation. Module namespaces contain only members from the containing module that share the same namespace name. Assembly namespaces contain members for all modules in the containing assembly that share the same namespace name. Compilation namespaces contain all members, from source or referenced metadata (assemblies and modules) that share the same namespace name. The containing compilation for compilation namespaces. If a namespace has Assembly or Compilation extent, it may be composed of multiple namespaces that are merged together. If so, ConstituentNamespaces returns all the namespaces that were merged. If this namespace was not merged, returns an array containing only this namespace. Containing assembly. Containing module. Gets the kind of this symbol. Implements visitor pattern. Get this accessibility that was declared on this symbol. For symbols that do not have accessibility declared on them, returns NotApplicable. Returns data decoded from Obsolete attribute or null if there is no Obsolete attribute. This property returns ObsoleteAttributeData.Uninitialized if attribute arguments haven't been decoded yet. Returns declared accessibility of most accessible type within this namespace or within a containing namespace recursively. Valid return values: Friend, Public, NotApplicable - if there are no types. Calculate declared accessibility of most accessible type within this namespace or within a containing namespace recursively. Expected to be called at most once per namespace symbol, unless there is a race condition. Valid return values: Friend, Public, NotApplicable - if there are no types. Returns true if namespace contains types accessible from the target assembly. Returns true if this symbol is "shared"; i.e., declared with the "Shared" modifier or implicitly always shared. Lookup a nested namespace. Sequence of names for nested child namespaces. Symbol for the most nested namespace, if found. Nothing if namespace or any part of it can not be found. Lookup an immediately nested type referenced from metadata, names should be compared case-sensitively. Full type name possibly with generic name mangling. Symbol for the type, or Nothing if the type isn't found. This is an entry point for the Binder to collect extension methods with the given name declared within this (compilation merged or module level) namespace, so that methods from the same type are grouped together. This is an entry point for the Binder. Its purpose is to add names of viable extension methods declared in this (compilation merged or module level) namespace to nameSet parameter. Add names of viable extension methods declared in this (compilation merged or module level) namespace to nameSet parameter. The 'appendThrough' parameter allows RetargetingNamespaceSymbol to delegate majority of the work to the underlying namespace symbol, but still perform viability check on RetargetingMethodSymbol. Populate the map with all probable extension methods declared within this namespace, so that methods from the same type were grouped together within each bucket. Gets all extension methods in this namespace given a method's name. Return the set of types that should be checked for presence of extension methods in order to build a map of extension methods for the namespace. Populate the map with all probable extension methods in membersByName parameter. Returns True if an extension method was appended, False otherwise. This method is overridden by RetargetingNamespaceSymbol and allows it to delegate majority of the work to the underlying namespace symbol, but still retarget method symbols before they are added to the map of extension methods. Represents a parameter of a method or property. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Is this ByRef parameter. Is parameter explicitly declared ByRef. Can be different from IsByRef only for String parameters of Declare methods. Is this Out parameter (metadata flag In is set). Is this In parameter (metadata flag Out is set). True if the parameter flows data out of the method. Describes how the parameter is marshalled when passed to native code. Null if no specific marshalling information is available for the parameter. PE symbols don't provide this information and always return Nothing. Returns the marshalling type of this field, or 0 if marshalling information isn't available. By default this information is extracted from if available. Since the compiler does only need to know the marshalling type of symbols that aren't emitted PE symbols just decode the type from metadata and don't provide full marshalling information. Gets the type of this parameter. The list of custom modifiers, if any, associated with the parameter type. Custom modifiers associated with the ref modifier, or an empty array if there are none. Gets the ordinal order of this parameter. The first type parameter has ordinal zero. Returns true if this parameter was declared as a ParamArray. Returns true if this parameter was declared as Optional. Returns true if the parameter explicitly specifies a default value to be passed when no value is provided as an argument to a call. True if the parameter has a default value defined in source via an optional parameter syntax, or the parameter is from metadata and HasDefault and Optional metadata flags are set, or the parameter is from metadata, has Optional flag set and or is specified. The default value can be obtained with the property. Returns the default value of this parameter. If returns false, then this property throws an InvalidOperationException. Returns data decoded from Obsolete attribute or null if there is no Obsolete attribute. This property returns ObsoleteAttributeData.Uninitialized if attribute arguments haven't been decoded yet. Returns the default value of this parameter as a ConstantValue. Return nothing if there isn't a default value. Create a new ParameterSymbol with everything the same except the owner. Used for property accessor methods, for example. Note: This is only implemented for those subclasses (e.g., SourceParameterSymbol) for which it is required. Thus, the base implementation throws an exception instead of being MustOverride. The index of the parameter which CallerArgumentExpressionAttribute points to. Returns -1 if there is no valid CallerArgumentExpressionAttribute. The situation is different for reduced extension method parameters, where a value of -2 is returned for no valid attribute, -1 for 'Me' parameter, and the reduced index (i.e, the original index minus 1) otherwise. Represents a property. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Source: Returns False; properties from source cannot return by reference. Metadata: Returns whether or not this property returns by reference. Gets the type of the property. Returns the list of custom modifiers, if any, associated with the type of the property. Custom modifiers associated with the ref modifier, or an empty array if there are none. Gets the parameters of this property. If this property has no parameters, returns an empty list. Optimization: in many cases, the parameter count (fast) is sufficient and we don't need the actual parameter symbols (slow). The default implementation is always correct, but may be unnecessarily slow. True if the property itself Is excluded from code coverage instrumentation. True for source properties marked with . True if this symbol has a special name (metadata flag SpecialName is set). Returns true if this property is a default property. Returns true if this is a read-only property; i.e., has no set accessor. Indicates if the property can be read, which means this type overrides OR inherits a getter for this property. Returns true if this is a write-only property; i.e., has no get accessor. Indicates if the property has a Set accessor. Indicates if the property can be written into, which means this property has a setter or it is a getter only autoproperty accessed in a corresponding constructor or initializer. If the setter is init-only, we also check that it is accessed in a constructor on Me/MyBase/MyClass or is a target of a member initializer in an object member initializer. Gets the associated "get" method for this property. If this property has no get accessor, returns Nothing. Retrieves Get method for this property or 'most derived' Get method from closest overridden property if such property exists. NOTE: It is not possible in VB, but possible in other languages (for example in C#) to override read-write property and provide override only for setter, thus inheriting getter's implementation. This method will find the Get method from the most-derived overridden property in this case Gets the associated "set" method for this property. If this property has no set accessor, returns Nothing. Retrieves Set method for this property or 'most derived' Set method from closest overridden property if such property exists. NOTE: It is not possible in VB, but possible in other languages (for example in C#) to override read-write property and provide override only for getter, thus inheriting setter's implementation. This method will find the Set method from the most-derived overridden property in this case Backing field of the property, or Nothing if the property doesn't have any. Properties imported from metadata return Nothing. Gets the attributes on event's associated field, if any. Returns an array of or an empty array if there are no attributes. Only WithEvent property may have any attributes applied on its backing field. Returns true if this property hides a base property by name and signature. The equivalent of the "hidebysig" flag in metadata. This property should not be confused with general property overloading in Visual Basic, and is not directly related. This property will only return true if this method hides a base property by name and signature (Overloads keyword). Gets the resolution priority of this property, 0 if not set. If this property overrides another property (because it both had the Overrides modifier and there correctly was a property to override), returns the overridden property. Helper method for accessors to get the overridden accessor methods. Should only be called by the accessor method symbols. True to get overridden getters, False to get overridden setters All the accessors of the given kind implemented by this property. Returns interface properties explicitly implemented by this property. Get the "this" parameter for this property. This is only valid for source fields. Return error code that has highest priority while calculating use site error for this symbol. Returns true if this property is an auto-created WithEvents property that takes place of a field member when the field is marked as WithEvents. Is this a property of a tuple type? If this is a property of a tuple type, return corresponding underlying property from the tuple underlying type. Otherwise, Nothing. Clone the property parameters for the accessor method. The parameters are cloned (rather than referenced from the property) since the ContainingSymbol needs to be set to the accessor. Is this an auto-generated property of a group class? Represents an assembly built by compiler. A Compilation the assembly is created for. Assembly's identity. A list of modules the assembly consists of. The first (index=0) module is a SourceModuleSymbol, which is a primary module, the rest are net-modules. Indices of duplicate assembly attributes, i.e. attributes that bind to the same constructor and have identical arguments, that must not be emitted. These indices correspond to the merged assembly attributes from source and added net modules, i.e. attributes returned by method. This override is essential - it's a base case of the recursive definition. Gets unique source assembly attributes that should be emitted, i.e. filters out attributes with errors and duplicate attributes. Returns true if the assembly attribute at the given index is a duplicate assembly attribute that must not be emitted. Duplicate assembly attributes are attributes that bind to the same constructor and have identical arguments. This method must be invoked only after all the assembly attributes have been bound. Returns a bag of netmodule assembly attributes and data decoded from well-known attributes. Returns null if there are no attributes applied on the symbol. Forces binding and decoding of attributes. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. NOTE: This method should always be kept as a NotOverridable method. If you want to override attribute binding logic for a sub-class, then override method. Returns data decoded from source assembly attributes or null if there are none. Forces binding and decoding of attributes. TODO: We should replace methods GetSourceDecodedWellKnownAttributeData and GetNetModuleDecodedWellKnownAttributeData with a single method GetDecodedWellKnownAttributeData, which merges DecodedWellKnownAttributeData from source and netmodule attributes. This represents what the user claimed in source through the AssemblyFlagsAttribute. It may be modified as emitted due to presence or absence of the public key. Get assembly level declaration errors. True if internals are exposed at all. Forces binding and decoding of attributes. This property shouldn't be accessed during binding as it can lead to attribute binding cycle. We may synthesize some well-known attributes for this assembly symbol. However, at synthesis time, it is too late to report diagnostics or cancel the emit. Instead, we check for use site errors on the types and members we know we'll need at synthesis time. Synthesized namespace that contains synthesized types or subnamespaces. All its members are stored in a table on . Represents a compiler generated field used to implement static locals. There are two kind of fields: the one, that holds the value, and the one, that holds initialization "flag". Represents a type parameter in a generic type or generic method. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Gets the ordinal order of this type parameter. The first type parameter has ordinal zero. Get the types that were directly specified as constraints on this type parameter. Duplicates and cycles are removed, although the collection may include redundant constraints where one constraint is a base type of another. Returns whether the parameterless constructor constraint was specified. The method that declares this type parameter The type that declares this type parameter Called by ConstraintTypes and Interfaces to allow derived classes to ensure constraints within the containing type or method are resolved in a consistent order, regardless of the order the callers query individual type parameters. Helper method to force type parameter constraints to be resolved. Get all constraints, with optional source location for each. This method is provided for constraint checking only, and should only be invoked for SourceTypeParameterSymbol or ErrorTypeParameterSymbol directly. There is currently no need to invoke this method for PETypeParameterSymbol. Resolve constraints, binding and checking for conflicts as necessary. This is an internal method for resolving dependent sets of constraints and handling cycles. It will be called indirectly for core implementations (SourceTypeParameterSymbol and PETypeParameterSymbol) as a result of accessing constraint properties on this class. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! If this is a type parameter of a reduced extension method, gets the type parameter definition that this type parameter was reduced from. Otherwise, returns Nothing. Return an array of substituted type parameters with duplicates removed. Symbol representing a using alias appearing in a compilation unit. Generally speaking, these symbols do not appear in the set of symbols reachable from the unnamed namespace declaration. In other words, when a using alias is used in a program, it acts as a transparent alias, and the symbol to which it is an alias is used in the symbol table. For example, in the source code 
 Imports o = System.Object
 Namespace NS
     partial class C : Inherits o : End Class
     partial class C : Inherits Object : End Class
     partial class C : Inherits System.Object : End Class
 End Namespace
all three declarations for class C are equivalent and result in the same symbol table object for C. However, these alias symbols do appear in the results of certain SemanticModel APIs. Specifically, for the base clause of the first of C's class declarations, the following APIs may produce a result that contains an AliasSymbol: 
     SemanticInfo SemanticModel.GetSemanticInfo(ExpressionSyntax expression);
     SemanticInfo SemanticModel.BindExpression(SyntaxNode location, ExpressionSyntax expression);
     SemanticInfo SemanticModel.BindType(SyntaxNode location, ExpressionSyntax type);
     SemanticInfo SemanticModel.BindNamespaceOrType(SyntaxNode location, ExpressionSyntax type);
Also, the following are affected if container=Nothing (and, for the latter, when container=Nothing or arity=0): 
     Public Function LookupNames(position As Integer, Optional container As NamespaceOrTypeSymbol = Nothing, Optional options As LookupOptions = LookupOptions.Default, Optional results As List(Of String) = Nothing) As IList(Of String)
     Public Function LookupSymbols(position As Integer,
                                  Optional container As NamespaceOrTypeSymbol = Nothing,
                                  Optional name As String = Nothing,
                                  Optional arity As Integer? = Nothing,
                                  Optional options As LookupOptions = LookupOptions.Default,
                                  Optional results As List(Of Symbol) = Nothing) As IList(Of Symbol)
The alias name. Gets the kind of this symbol. Gets the for the namespace or type referenced by the alias. Gets the locations where this symbol was originally defined. Get the syntax node(s) where this symbol was declared in source. The syntax node(s) that declared the symbol. To go the opposite direction (from syntax node to symbol), see . Returns true if this symbol was declared to override a base class members and was also restricted from further overriding; i.e., declared with the "NotOverridable" modifier. Never returns true for types. False Returns true if this symbol was declared as requiring an override; i.e., declared with the "MustOverride" modifier. Never returns true for types. False Returns true if this symbol was declared to override a base class members; i.e., declared with the "Overrides" modifier. Still returns true if the members was declared to override something, but (erroneously) no member to override exists. False Returns true if this member is overridable, has an implementation, and does not override a base class member; i.e., declared with the "Overridable" modifier. Does not return true for members declared as MustOverride or Overrides. False Returns true if this symbol is "shared"; i.e., declared with the "Shared" modifier or implicitly always shared. False Get this accessibility that was declared on this symbol. For symbols that do not have accessibility declared on them, returns NotApplicable. Get the symbol that logically contains this symbol. Using aliases in VB are always at the top level within a compilation unit, within the [Global] namespace declaration. We return that as the "containing" symbol, even though the alias isn't a member of the namespace as such. Determines whether the specified object is equal to the current object. The object to compare with the current object. Returns a hash code for the current object. Describes anonymous type/delegate in terms of fields/parameters Anonymous type/delegate location Anonymous type fields Anonymous type descriptor Key The key is being used to separate anonymous type templates, for example in an anonymous type symbol cache. The type descriptors with the same keys are supposed to map to 'the same' anonymous type template in terms of the same generic type being used for their implementation. Anonymous type is implicitly declared Anonymous delegate parameters, including one for return type This is ONLY used for debugging purpose Performs internal substitution of types in anonymous type descriptor fields and returns True if any of the fields was changed, in which case a new descriptor is returned in newDescriptor Describes anonymous type field in terms of its name, type and other attributes. Or describes anonymous delegate parameter, including "return" parameter, in terms of its name, type and other attributes. Anonymous type field/parameter name, not nothing and not empty Location of the field Anonymous type field/parameter type, must be not nothing when the field is passed to anonymous type descriptor Anonymous type field/parameter type, may be nothing when field descriptor is created, must be assigned before passing the descriptor to anonymous type descriptor. Once assigned, is considered to be 'sealed'. Anonymous type field is declared as a 'Key' field Does this describe a ByRef parameter of an Anonymous Delegate type This is ONLY used for debugging purpose Module implements Dev11 class CRC32 used in anonymous type GetHashCode implementation See [...\Language\Shared\crc32.cpp] for details This is actually calculating the reverse CRC computing the reverse CRC of 0 gives the table entry above Represents a .NET assembly. An assembly consists of one or more modules. The system assembly, which provides primitive types like Object, String, etc., e.g. mscorlib.dll. The value is provided by ReferenceManager and must not be modified. For SourceAssemblySymbol, non-missing coreLibrary must match one of the referenced assemblies returned by GetReferencedAssemblySymbols() method of the main module. If there is no existing assembly that can be used as a source for the primitive types, the value is a Compilation.MissingCorLibrary. The system assembly, which provides primitive types like Object, String, etc., e.g. mscorlib.dll. The value is a MissingAssemblySymbol if none of the referenced assemblies can be used as a source for the primitive types and the owning assembly cannot be used as the source too. Otherwise, it is one of the referenced assemblies returned by GetReferencedAssemblySymbols() method or the owning assembly. A helper method for ReferenceManager to set the system assembly, which provides primitive types like Object, String, etc., e.g. mscorlib.dll. Simple name of the assembly. This is equivalent to ., but may be much faster to retrieve for source code assemblies, since it does not require binding the assembly-level attributes that contain the version number and other assembly information. True if the assembly contains interactive code. If this symbol represents a metadata assembly returns the underlying . Otherwise, this returns . Get the name of this assembly. Target architecture of the machine. Indicates that this PE file makes Win32 calls. See CorPEKind.pe32BitRequired for more information (http://msdn.microsoft.com/en-us/library/ms230275.aspx). Gets a read-only list of all the modules in this assembly. (There must be at least one.) The first one is the main module that holds the assembly manifest. Gets the merged root namespace that contains all namespaces and types defined in the modules of this assembly. If there is just one module in this assembly, this property just returns the GlobalNamespace of that module. Given a namespace symbol, returns the corresponding assembly specific namespace symbol Does this symbol represent a missing assembly. Lookup a top level type referenced from metadata, names should be compared case-sensitively. Full type name, possibly with generic name mangling. Lookup a top level type referenced from metadata, names should be compared case-sensitively. Detect cycles during lookup. Full type name, possibly with generic name mangling. List of assemblies lookup has already visited (since type forwarding can introduce cycles). Returns the type symbol for a forwarded type based its canonical CLR metadata name. The name should refer to a non-nested type. If type with this name Is Not forwarded, null Is returned. Look up the given metadata type, if it Is forwarded. Look up the given metadata type, if it is forwarded. Lookup declaration for predefined CorLib type in this Assembly. Only valid if this assembly is the Cor Library Register declaration of predefined CorLib type in this Assembly. Continue looking for declaration of predefined CorLib type in this Assembly while symbols for new type declarations are constructed. Figure out if the target runtime supports default interface implementation. Return an array of assemblies involved in canonical type resolution of NoPia local types defined within this assembly. In other words, all references used by previous compilation referencing this assembly. Return an array of assemblies referenced by this assembly, which are linked (/l-ed) by each compilation that is using this AssemblySymbol as a reference. If this AssemblySymbol is linked too, it will be in this array too. Assembly is /l-ed by compilation that is using it as a reference. Returns true and a string from the first GuidAttribute on the assembly, the string might be null or an invalid guid representation. False, if there is no GuidAttribute with string argument. An empty list means there was no IVT attribute with matching . An IVT attribute without a public key setting is represented by an entry that is empty in the returned list Get symbol for predefined type from Cor Library used by this assembly. The symbol for the pre-defined type or Nothing if the type is not defined in the core library The NamedTypeSymbol for the .NET System.Object type, which could have a TypeKind of Error if there was no COR Library in a compilation using the assembly. Get symbol for predefined type from Cor Library used by this assembly. Lookup a type within the assembly using its canonical CLR metadata name (names are compared case-sensitively). Symbol for the type or null if type cannot be found or is ambiguous. Lookup a type within the assembly using its canonical CLR metadata name (names are compared case-sensitively). If search within assembly fails, lookup in assemblies referenced by the primary module. For source assembly, this is equivalent to all assembly references given to compilation. Extra restrictions apply when searching for a well-known type. In particular, the type must be public. While resolving the name, consider only types following CLS-compliant generic type names and arity encoding (ECMA-335, section 10.7.2). I.e. arity is inferred from the name and matching type must have the same emitted name and arity. When set, any duplicate coming from corlib is ignored. In cases a type could not be found because of ambiguity, we return two of the candidates that caused the ambiguity. Lookup a top level type within the assembly or one of the assemblies referenced by the primary module, names are compared case-sensitively. In case of ambiguity, type from this assembly wins, otherwise Nothing is returned. Symbol for the type or Nothing if type cannot be found or ambiguous. If this property returns false, it is certain that there are no extension methods (from language perspective) inside this assembly. If this property returns true, it is highly likely (but not certain) that this type contains extension methods. This property allows the search for extension methods to be narrowed much more quickly. !!! Note that this property can mutate during lifetime of the symbol !!! !!! from True to False, as we learn more about the assembly. !!! Lookup member declaration in predefined CorLib type used by this Assembly. Lookup member declaration in predefined CorLib type in this Assembly. Only valid if this assembly is the Cor Library Class to represent custom attributes attached to symbols. The attribute class. The constructor on the attribute class. Constructor arguments on the attribute. Named (property value) arguments on the attribute. Matches an attribute by metadata namespace, metadata type name. Does not load the type symbol for the attribute. True if the attribute data matches. Matches an attribute by metadata namespace, metadata type name and metadata signature. Does not load the type symbol for the attribute. Attribute to match. An index of the target constructor signature in signatures array, -1 if this is not the target attribute. Matching an attribute by name does not load the attribute class. This subclass of MetadataDecoder is specifically for finding method symbols corresponding to method MemberRefs. The parent implementation is unsuitable because it requires a PEMethodSymbol for context when decoding method type parameters and no such context is available because it is precisely what we are trying to find. Since we know in advance that there will be no context and that signatures decoded with this class will only be used for comparison (when searching through the methods of a known TypeSymbol), we can return indexed type parameters instead. We know that we'll never have a method context because that's what we're trying to find. Instead, just return an indexed type parameter that will make comparison easier. This override can handle non-PE types. Search through the members of the type symbol to find the method that matches a particular signature. A MemberRef or a MethodDef handle that can be used to obtain the name and signature of the method True to only return a method. The matching method symbol, or null if the inputs do not correspond to a valid method. Helper class to resolve metadata tokens and signatures. Type context for resolving generic type arguments. Method context for resolving generic method type arguments. Lookup a type defined in referenced assembly. Lookup a type defined in a module of a multi-module assembly. Lookup a type defined in this module. This method will be called only if the type we are looking for hasn't been loaded yet. Otherwise, MetadataDecoder would have found the type in TypeDefRowIdToTypeMap based on its TypeDef row id. Perform a check whether the type or at least one of its generic arguments is defined in the specified assemblies. The check is performed recursively. Find canonical type for NoPia embedded type. Symbol for the canonical type or an ErrorTypeSymbol. Never returns null. Represents an assembly imported from a PE. An Assembly object providing metadata for the assembly. A MetadataDocumentationProvider providing XML documentation for this assembly. The list of contained PEModuleSymbol objects. The list doesn't use type ReadOnlyCollection(Of PEModuleSymbol) so that we can return it from Modules property as is. An array of assemblies involved in canonical type resolution of NoPia local types defined within this assembly. In other words, all references used by a compilation referencing this assembly. The array and its content is provided by ReferenceManager and must not be modified. An array of assemblies referenced by this assembly, which are linked (/l-ed) by each compilation that is using this AssemblySymbol as a reference. If this AssemblySymbol is linked too, it will be in this array too. The array and its content is provided by ReferenceManager and must not be modified. Assembly is /l-ed by compilation that is using it as a reference. Look up the assemblies to which the given metadata type Is forwarded. Pass true to look up fullName case-insensitively. WARNING: more expensive. Returns the actual casing of the matching name. The assemblies to which the given type Is forwarded Or null, if there isn't one. The returned assemblies may also forward the type. This is for perf, not for correctness. The class to represent all events imported from a PE/module. This is for perf, not for correctness. The class to represent all fields imported from a PE/module. This symbol is used as a type for a "fake" required custom modifier added for ByRef fields. This allows us to report use site errors for ByRef fields, and, at the same time, allows us to accurately match them by signature (since this instance is unique and is not used for anything else) without adding full support for RefKind and RefCustomModifiers This is for perf, not for correctness. The module containing the namespace. This is for perf, not for correctness. The class to represent all methods imported from a PE/module. A single field to hold optional auxiliary data. In many scenarios it is possible to avoid allocating this, thus saving total space in . Even for lazily-computed values, it may be possible to avoid allocating if the computed value is a well-known "empty" value. In this case, bits in are used to indicate that the lazy values have been computed and, if is null, then the "empty" value should be inferred. Holds infrequently accessed fields. See for an explanation. Associate the method with a particular property. Returns false if the method is already associated with a property or event. Associate the method with a particular event. Returns false if the method is already associated with a property or event. This is for perf, not for correctness. Represents a net-module imported from a PE. Can be a primary module of an assembly. Owning AssemblySymbol. This can be a PEAssemblySymbol or a SourceAssemblySymbol. A Module object providing metadata. Global namespace. Cache the symbol for well-known type System.Type because we use it frequently (for attributes). The same value as ConcurrentDictionary.DEFAULT_CAPACITY This is a map from TypeDef handle to the target . It is used by to speed up type reference resolution for metadata coming from this module. The map is lazily populated as we load types from the module. This is a map from TypeRef row id to the target . It is used by to speed-up type reference resolution for metadata coming from this module. The map is lazily populated by as we resolve TypeRefs from the module. This is for perf, not for correctness. Returns a tuple of the assemblies this module forwards the given type to. Type to look up. Pass true to look up fullName case-insensitively. WARNING: more expensive. Returns the actual casing of the matching name. A tuple of the forwarded to assemblies. The returned assemblies may also forward the type. The class to represent all types imported from a PE/module. A map of types immediately contained within this type grouped by their name (case-insensitively). A set of all the names of the members in this type. A map of members immediately contained within this type grouped by their name (case-insensitively). Lazily initialized by TypeKind property. Using Integer type to make sure read/write operations are atomic. Some simple sanity checks if a property can actually be a withevents property Return true if the type parameters specified on the nested type (Me), that represent the corresponding type parameters on the containing types, in fact match the actual type parameters on the containing types. Force all declaration errors to be generated. This is for perf, not for correctness. Returns the index of the first member of the specific kind. Returns the number of members if not found. Returns all members of the specific kind, starting at the optional offset. Members of the same kind are assumed to be contiguous. The class to represent top level types imported from a PE/module. The base class to represent a namespace imported from a PE/module. Namespaces that differ only by casing in name are merged. A map of namespaces immediately contained within this namespace grouped by their name (case-insensitively). A map of types immediately contained within this namespace grouped by their name (case-insensitively). A map of NoPia local types immediately contained in this assembly. Maps fully-qualified type name to the row id. Returns PEModuleSymbol containing the namespace. PEModuleSymbol containing the namespace. Initializes m_Namespaces and m_Types maps with information about namespaces and types immediately contained within this namespace. The sequence of groups of TypeDef row ids for types contained within the namespace, recursively including those from nested namespaces. The row ids must be grouped by the fully-qualified namespace name in case-sensitive manner. There could be multiple groups for each fully-qualified namespace name. The groups must be sorted by their key in case-insensitive manner. Empty string must be used as namespace name for types immediately contained within Global namespace. Therefore, all types in THIS namespace, if any, must be in several first IGroupings. Create symbols for nested namespaces and initialize m_Namespaces map. Create symbols for nested types and initialize m_Types map. For test purposes only. Return the set of types that should be checked for presence of extension methods in order to build a map of extension methods for the namespace. The class to represent all, but Global, namespaces imported from a PE/module. Namespaces that differ only by casing in name are merged. The parent namespace. There is always one, Global namespace contains all top level namespaces. The name of the namespace. The sequence of groups of TypeDef row ids for types contained within the namespace, recursively including those from nested namespaces. The row ids are grouped by the fully-qualified namespace name in case-sensitive manner. There could be multiple groups for each fully-qualified namespace name. The groups are sorted by their key in case-insensitive manner. Empty string is used as namespace name for types immediately contained within Global namespace. Therefore, all types in this namespace, if any, will be in several first IGroupings. This member is initialized by constructor and is cleared in EnsureAllMembersLoaded as soon as symbols for children are created. Constructor. Name of the namespace, must be not empty. Containing namespace. The sequence of groups of TypeDef row ids for types contained within the namespace, recursively including those from nested namespaces. The row ids are grouped by the fully-qualified namespace name in case-sensitive manner. There could be multiple groups for each fully-qualified namespace name. The groups are sorted by their key in case-insensitive manner. Empty string is used as namespace name for types immediately contained within Global namespace. Therefore, all types in this namespace, if any, will be in several first IGroupings. Calculate declared accessibility of most accessible type within this namespace or within a containing namespace recursively. Expected to be called at most once per namespace symbol, unless there is a race condition. Valid return values: Friend, Public, NotApplicable - if there are no types. This is for perf, not for correctness. The class to represent all types imported from a PE/module. The index of a CallerArgumentExpression. The value means uninitialized, -1 means Not found. Otherwise, the index of the CallerArgumentExpression. Attributes filtered out from m_lazyCustomAttributes, ParamArray, etc. This is for perf, not for correctness. The class to represent all properties imported from a PE/module. Marks property as definitely IsWithEvents or not. The effects of this change cannot be undone. Will have no effect if someone already asked if property is IsWithEvents (and will assert since it is not supposed to happen). For the property to be considered valid, accessor signatures must be consistent with each other, and accessor signatures must be consistent with the property signature ignoring ByRef. These requirements are stricter than Dev11 which allows many inconsistencies including different numbers of parameters. This is for perf, not for correctness. The class to represent all generic type parameters imported from a PE/module. Actually stores First error calculating bounds. This is for perf, not for correctness. Tuples can be represented using tuple syntax and be given names. However, the underlying representation for tuples unifies to a single underlying tuple type, System.ValueTuple. Since the names aren't part of the underlying tuple type they have to be recorded somewhere else. Roslyn records tuple names in an attribute: the TupleElementNamesAttribute. The attribute contains a single string array which records the names of the tuple elements in a pre-order depth-first traversal. If the type contains nested parameters, they are also recorded in a pre-order depth-first traversal. can be used to extract tuple names and types from metadata and create a with attached names. For instance, a method returning a tuple Function M() As (x As Integer, y As Integer) will be encoded using an attribute on the return type as follows < return: TupleElementNamesAttribute({ "x", "y" }) > Function M() As System.ValueTuple(Of Integer, Integer) For nested type parameters, we expand the tuple names in a pre-order traversal: Class C Inherits BaseType(Of (e3 As (e1 As Integer, e2 As Integer), e4 As Integer)) becomes < TupleElementNamesAttribute({ "e3", "e4", "e1", "e2" }) > Class C Inherits BaseType(of System.ValueTuple(of System.ValueTuple(Of Integer, Integer), Integer) Represents a retargeting custom attribute Essentially this is a wrapper around another AssemblySymbol that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. For example, compilation C1 references v1 of Lib.dll and compilation C2 references C1 and v2 of Lib.dll. In this case, in context of C2, all types from v1 of Lib.dll leaking through C1 (through method signatures, etc.) must be retargeted to the types from v2 of Lib.dll. This is what RetargetingAssemblySymbol is responsible for. In the example above, modules in C2 do not reference C1.m_AssemblySymbol, but reference a special RetargetingAssemblySymbol created for C1 by ReferenceManager. Here is how retargeting is implemented in general: - Symbols from underlying assembly are substituted with retargeting symbols. - Symbols from referenced assemblies that can be reused as is (i.e. doesn't have to be retargeted) are used as is. - Symbols from referenced assemblies that must be retargeted are substituted with result of retargeting. The underlying AssemblySymbol, it leaks symbols that should be retargeted. This cannot be an instance of RetargetingAssemblySymbol. The list of contained ModuleSymbol objects. First item in the list is RetargetingModuleSymbol that wraps corresponding SourceModuleSymbol from m_UnderlyingAssembly.Modules list, the rest are PEModuleSymbols for added modules. An array of assemblies involved in canonical type resolution of NoPia local types defined within this assembly. In other words, all references used by a compilation referencing this assembly. The array and its content is provided by ReferenceManager and must not be modified. An array of assemblies referenced by this assembly, which are linked (/l-ed) by each compilation that is using this AssemblySymbol as a reference. If this AssemblySymbol is linked too, it will be in this array too. The array and its content is provided by ReferenceManager and must not be modified. A map from a local NoPia type to corresponding canonical type. Assembly is /l-ed by compilation that is using it as a reference. Retargeted custom attributes Constructor. The underlying AssemblySymbol, cannot be an instance of RetargetingAssemblySymbol. Assembly is /l-ed by compilation that is using it as a reference. The underlying AssemblySymbol. This cannot be an instance of RetargetingAssemblySymbol. Lookup declaration for FX type in this Assembly. This is for perf, not for correctness. Owning RetargetingModuleSymbol. The underlying EventSymbol, cannot be another RetargetingEventSymbol. Retargeted custom attributes This is for perf, not for correctness. Represents a field in a RetargetingModuleSymbol. Essentially this is a wrapper around another FieldSymbol that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. Owning RetargetingModuleSymbol. The underlying FieldSymbol, cannot be another RetargetingFieldSymbol. Retargeted custom attributes This is for perf, not for correctness. Represents a method in a RetargetingModuleSymbol. Essentially this is a wrapper around another MethodSymbol that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. Owning RetargetingModuleSymbol. The underlying MethodSymbol, cannot be another RetargetingMethodSymbol. Retargeted custom attributes Retargeted return type attributes This is for perf, not for correctness. Represents a primary module of a . Essentially this is a wrapper around another that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. Here is how retargeting is implemented in general: - Symbols from underlying module are substituted with retargeting symbols. - Symbols from referenced assemblies that can be reused as is (i.e. don't have to be retargeted) are used as is. - Symbols from referenced assemblies that must be retargeted are substituted with result of retargeting. Owning . The underlying , cannot be another . The map that captures information about what assembly should be retargeted to what assembly. Key is the referenced by the underlying module, value is the corresponding referenced by this module, and corresponding retargeting map for symbols. Retargeted custom attributes Constructor. Owning assembly. Underlying , cannot be another . The underlying , cannot be another . A helper method for ReferenceManager to set AssemblySymbols for assemblies referenced by this module. This is for perf, not for correctness. Retargeting map from underlying module to this one. Retargeting map from underlying module to the retargeting module. RetargetingAssemblySymbol owning retargeting module. The map that captures information about what assembly should be retargeted to what assembly. Key is the AssemblySymbol referenced by the underlying module, value is the corresponding AssemblySymbol referenced by the retargeting module, and corresponding retargeting map for symbols. The underlying ModuleSymbol for the retargeting module. Perform a check whether the type or at least one of its generic arguments is an explicitly defined local type. The check is performed recursively. Represents a type of a RetargetingModuleSymbol. Essentially this is a wrapper around another NamedTypeSymbol that is responsible for retargeting referenced symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. Owning RetargetingModuleSymbol. The underlying NamedTypeSymbol, cannot be another RetargetingNamedTypeSymbol. Retargeted custom attributes This method is called directly by a Binder when it uses this type. This method is called directly by a Binder when it uses this type. Make sure we retarget methods when underlying type checks their viability. Force all declaration errors to be generated. This is for perf, not for correctness. Represents a namespace of a RetargetingModuleSymbol. Essentially this is a wrapper around another NamespaceSymbol that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. Owning RetargetingModuleSymbol. The underlying NamespaceSymbol, cannot be another RetargetingNamespaceSymbol. Calculate declared accessibility of most accessible type within this namespace or within a containing namespace recursively. Expected to be called at most once per namespace symbol, unless there is a race condition. Valid return values: Friend, Public, NotApplicable - if there are no types. This method is called directly by a Binder when it uses this module level namespace. This method is called when this namespace is part of a merged namespace and we are trying to build a map of extension methods for the whole merged namespace. Make sure we retarget methods when types of the underlying namespace add them to the map. This method is called directly by a Binder when it uses this module level namespace. Make sure we retarget methods when underlying namespace checks their viability. This is for perf, not for correctness. Represents a parameter of a RetargetingMethodSymbol. Essentially this is a wrapper around another ParameterSymbol that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. The underlying ParameterSymbol, cannot be another RetargetingParameterSymbol. Retargeted custom attributes Owning RetargetingMethodSymbol. Owning RetargetingPropertySymbol. This is for perf, not for correctness. Owning RetargetingModuleSymbol. The underlying PropertySymbol, cannot be another RetargetingPropertySymbol. Retargeted custom attributes This is for perf, not for correctness. Represents a type parameter in a RetargetingModuleSymbol. Essentially this is a wrapper around another TypeParameterSymbol that is responsible for retargeting symbols from one assembly to another. It can retarget symbols for multiple assemblies at the same time. Owning RetargetingModuleSymbol. The underlying TypeParameterSymbol, cannot be another RetargetingTypeParameterSymbol. This is for perf, not for correctness. This method finds an attribute by metadata name and signature. The algorithm for signature matching is similar to the one in Module.GetTargetAttributeSignatureIndex. Note, the signature matching is limited to primitive types and System.Type. It will not match an arbitrary signature but it is sufficient to match the signatures of the current set of well known attributes. Attribute to match. Compares the namespace and type name with the attribute's namespace and type name. Returns true if they are the same. Information decoded from well-known custom attributes applied on an event. Information decoded from early well-known custom attributes applied on a method. Information decoded from well-known custom attributes applied on a method. Information decoded from early well-known custom attributes applied on a parameter. Information decoded from early well-known custom attributes applied on a type. a link in a dependency chain it means that "dependent" is dependent on the rest of the chain. "kind" tells what kind of dependency this is. Source types may have dependencies via inheritance or containment The diagnostics is different in those cases. Given base being resolved chain and current type produce the diagnostics or Nothing if there is no cycle detected Detects situations when a type participates in a dependency loop And generates appropriate diagnostics. No diagnostics means there was no loop if there is a dependency chain from "current" to the "root" Returning Nothing, means that there is no dependency Returning Empty, means that root and current are the same and we have a 0-length dependency Otherwise a dependence chain is formed. Verifies that given symbol does not have loops in its inheritance chain and reports appropriate diagnostics. Verifies that given symbol does not have loops in its inheritance hierarchy and reports appropriate diagnostics. A tuple of TypeParameterSymbol and DiagnosticInfo, created for errors reported from ConstraintsHelper rather than creating Diagnostics directly. This decouples constraints checking from syntax and Locations, and supports callers that may want to create Location instances lazily or not at all. Helper methods for generic type parameter constraints. There are two sets of methods: one set for resolving constraint "bounds" (that is, determining the effective base type, interface set, etc.), and another set for checking for constraint violations in type and method references. Bounds are resolved by calling one of the ResolveBounds overloads. Typically bounds are resolved by each TypeParameterSymbol at, or before, one of the corresponding properties (BaseType, Interfaces, etc.) is accessed. Resolving bounds may result in errors (cycles, inconsistent constraints, etc.) and it is the responsibility of the caller to report any such errors as declaration errors or use-site errors (depending on whether the type parameter was from source or metadata) and to ensure bounds are resolved for source type parameters even if the corresponding properties are never accessed directly. Constraints are checked by calling one of the CheckConstraints or CheckAllConstraints overloads for any generic type or method reference from source. In some circumstances, references are checked at the time the generic type or generic method is bound and constructed by the Binder. In those case, it is sufficient to call one of the CheckConstraints overloads since compound types (such as A(Of T).B(Of U) or A(Of B(Of T))) are checked incrementally as each part is bound. In other cases however, constraint checking needs to be delayed to prevent cycles where checking constraints requires binding the syntax that is currently being bound (such as the constraint in Class C(Of T As C(Of T)). In those cases, the caller must lazily check constraints, and since the types may be compound types, it is necessary to call CheckAllConstraints. Enum used internally by RemoveDirectConstraintConflicts to track what type constraint has been seen, to report conflicts between { 'Structure', 'Class', [explicit type] }. The 'New' constraint does not need to be tracked for those conflicts. Return the constraints for the type parameter with any cycles or conflicting constraints reported as errors and removed. Check all generic constraints on the given type and any containing types (such as A(Of T) in A(Of T).B(Of U)). This includes checking constraints on generic types within the type (such as B(Of T) in A(Of B(Of T)())). Check type parameters for the containing type or method symbol. The type parameters are assumed to be the original definitions of type parameters from the containing type or method, and the TypeSubstitution instance is used for substituting type parameters within the constraints of those type parameters, so the substitution should map from type parameters to type arguments. Return the most derived type from the set of constraint types on this type parameter and any type parameter it depends on. Returns Nothing if there are no concrete constraint types. If there are multiple constraints, returns the most derived, ignoring any subsequent constraints that are neither more or less derived. This method assumes there are no constraint cycles. Return the most derived class type from the set of constraint types on this type parameter and any type parameter it depends on. Returns Nothing if there are no concrete constraint types. If there are multiple constraints, returns the most derived, ignoring any subsequent constraints that are neither more or less derived. This method assumes there are no constraint cycles. Unlike GetBaseConstraintType, this method will always return a NamedTypeSymbol representing a class: returning System.ValueType for value types, System.Array for arrays, and System.Enum for enums. Populate the collection with all constraints for the type parameter, traversing any constraints that are also type parameters. The result is a collection of type and flag constraints, with no type parameter references. This method assumes there are no constraint cycles. A tuple of type parameter and constraint type. Return true if the class type has a public parameterless constructor. Return true if the constraints collection contains the given type constraint. True if the syntax tree is an embedded syntax tree Manages symbols from automatically embedded syntax trees. Automatically embedded symbols (types, methods and fields) used in the current compilation Non-0 indicates that the collection of referenced symbols is sealed and so no new symbols are supposed to be added. True if StandardModuleAttribute was used in the current compilation Marks StandardModuleAttributeReference type as being references in the current compilation. This method is to be used when a new type symbol for a module is being created; we cannot pass the actual StandardModuleAttribute type symbol because the symbol table is being constructed and calling Compilation.GetWellKnownType(...) will cause infinite recursion. It does not seem reasonable to special case this in symbol creation, so we just mark StandardModuleAttribute attribute as referenced and then add the actual symbol when MarkAllDeferredSymbols(...) is called. Mark all deferred types as referenced Returns True if any embedded symbols are referenced. WARNING: the referenced symbols collection may not be sealed yet!!! Makes a snapshot of the current set of referenced symbols filtered by, the set of symbols provided; may be called before the referenced symbol collection is sealed. Checks if the embedded symbol provided is in the collection and adds it into collection if not. See description of AddReferencedSymbolWithDependents for more details of how it actually works. Returns True if the embedded symbol is known to be referenced in the current compilation. Seals the collection of referenced symbols, all *new* symbols passed to SpawnSymbolCollection(...) will cause assert and be ignored. Checks if the embedded symbol provided is present in the 'allSymbols' and if not adds it into 'allSymbols' as well as to the collection of referenced symbols managed by this manager. Also adds all the 'dependent' symbols, i.e. symbols which must also be marked as referenced if 'symbol' is referenced. NOTE that when a new embedded symbol is being added to the collection of referenced symbols it should be added along with all the 'dependent' symbols. For example, if we add a method symbol (T1.M1) we should ensure the containing type symbol (T1) is added too, as well as its constructor (T1..ctor) and maybe attribute(s) (Attr1) set on T1 and their constructors/fields (Attr1..ctor), etc... All dependent symbols must be added in the current thread not depending on the other concurrent threads and avoiding possible race. Thus, let's suppose we have the following dependencies: T1.M1 -> { T1, T1..ctor, Attr1, Attr1..ctor, ... } we cannot just check if T1.M1 exists in the collection of referenced symbols and not add dependent symbols if it does; the reason is that T1.M1 may be added by a concurrent thread, but its dependencies may not be added by that thread yet. So we need to calculate all dependencies and try add all the symbols together. On the other hand it should be avoided that the method *always* goes through all the dependencies for each symbol even though it may be definitely known that the symbol is added in one of the previous operations by *the same thread*. To serve this purpose the method uses 'allSymbols' collection to actually check whether or not the symbol is added to the collection. This makes possible to reuse the same collection in several consequent calls to AddReferencedSymbolWithDependents from the same thread; for example in case one thread consequently adds lots of symbols, the thread may use the same 'allSymbols' instance for efficient symbol filtering. Lazily created parsed representation of VB Core content Returns information about the reason that this type is in error. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! If we believe we know which symbol the user intended, then we should retain that information in the corresponding error symbol - it can be useful for deciding how to handle the error. Return why the candidate symbols were bad. When constructing this ErrorTypeSymbol, there may have been symbols that seemed to be what the user intended, but were unsuitable. For example, a type might have been inaccessible, or ambiguous. This property returns the possible symbols that the user might have intended. It will return no symbols if no possible symbols were found. See the CandidateReason property to understand why the symbols were unsuitable. Force all declaration errors to be generated. Implementation of IEqualityComparer for EventSymbol, with options for various aspects to compare. This instance is used when trying to determine which implemented interface event is implemented by a event with an Implements clause, according to VB rules. This comparer uses event signature that may come from As clause delegate or from a parameter list. The event signatures are compared without regard to name (including the interface part, if any) and the return type must match. (NOTE: that return type of implementing event is always Void) This instance is used to check whether one event overrides another, according to the VB definition. This instance is intended to reflect the definition of signature equality used by the runtime (ECMA 335 Section 8.6.1.6). It considers type, name, parameters, and custom modifiers. This instance is used to compare potential WinRT fake events in type projection. FIXME(angocke): This is almost certainly wrong. The semantics of WinRT conflict comparison should probably match overload resolution (i.e., we should not add a member to lookup that would result in ambiguity), but this is closer to what Dev12 does. The real fix here is to establish a spec for how WinRT conflict comparison should be performed. Once this is done we should remove these comments. An error type symbol with name and diagnostic. More info can be added in the future. Returns information about the reason that this type is in error. Represents a field or property initializer. Holds the symbol and the syntax for the initialization. The fields or properties being initialized, or Nothing if this represents an executable statement in script code. We can get into a multiple properties case when multiple WithEvents fields are initialized with As New ... A reference to , , , (top-level statement). A sum of widths of spans of all preceding initializers (instance and static initializers are summed separately, and trivias are not counted). Initializer for an executable statement in script code. The initializer syntax for the statement. Initializes a new instance of the structure. The field. The initializer syntax for the field. Initializes a new instance of the structure. Initializes a new instance of the structure. The property. The initializer syntax for the property. Indexed type parameters are used in place of type parameters for method signatures. There is a unique mapping from index to a single IndexedTypeParameterSymbol. They don't have a containing symbol or locations. They do not have constraints, variance, or attributes. Create a vector of n dummy type parameters. Always reuses the same type parameter symbol for the same position. The base class for potentially constructible (i.e. with known arity) error type symbols Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! An InstanceTypeSymbol is a NamedTypeSymbol that is a pure instance type, where the class (and any containing classes) have no type substitutions applied. This class provide shared implementation for types whose definition is (possibly lazily) constructed from source or metadata. It provides the shared implementation between these two, primarily the implementation of Construct and InternalSubstituteTypeParameters. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! A [Resume] or [On Error Resume Next] statement. A structure used to lexically order symbols. For performance, it's important that this be a STRUCTURE, and be able to be returned from a symbol without doing any additional allocations (even if nothing is cached yet.) Embedded kind of the tree. If -1, symbol is in metadata or embedded or otherwise not it source. Note that TreeOrdinal is only used for EmbeddedSymbolKind.None trees, thus negative ordinals of embedded trees do not interfere Position within the tree. Doesn't need to exactly match the span returned by Locations, just be good enough to sort. In other words, we don't need to go to extra work to return the location of the identifier, just some syntax location is fine. Negative value indicates that the structure was not initialized yet, is used for lazy initializations only along with LexicalSortKey.NotInitialized WARNING: Only use this if the location is obtainable without allocating it (even if cached later). E.g., only if the location object is stored in the constructor of the symbol. WARNING: Only use this if the node is obtainable without allocating it (even if cached later). E.g., only if the node is stored in the constructor of the symbol. In particular, do not call this on the result of a GetSyntax() call on a SyntaxReference. WARNING: Only use this if the token is obtainable without allocating it (even if cached later). E.g., only if the node is stored in the constructor of the symbol. In particular, do not call this on the result of a GetSyntax() call on a SyntaxReference. Compare two lexical sort keys in a compilation. This class provides an easy way to combine a MethodSignatureComparer and a PropertySignatureComparer to create a unified MemberSignatureComparer (e.g. for use in a HashSet). This instance is used to compare potential WinRT fake members in type projection. FIXME(angocke): This is almost certainly wrong. The semantics of WinRT conflict comparison should probably match overload resolution (i.e., we should not add a member to lookup that would result in ambiguity), but this is closer to what Dev12 does. The real fix here is to establish a spec for how WinRT conflict comparison should be performed. Once this is done we should remove these comments. A MergedNamespaceSymbol represents a namespace that merges the contents of two or more other namespaces. Any sub-namespaces with the same names are also merged if they have two or more instances. Merged namespaces are used to merged the symbols from multiple metadata modules and the source "module" into a single symbol tree that represents all the available symbols. The compiler resolves names against Me merged set of symbols. Typically there will not be very many merged namespaces in a Compilation: only the root namespaces and namespaces that are used in multiple referenced modules. (Microsoft, System, System.Xml, System.Diagnostics, System.Threading, ...) Create a possibly merged namespace symbol representing global namespace on an assembly level. Create a possibly merged namespace symbol. If only a single namespace is passed it, it is just returned directly. If two or more namespaces are passed in, then a new merged namespace is created with the given extent and container. The namespace extent to use, IF a merged namespace is created. The containing namespace to used, IF a merged namespace is created. One or more namespaces to merged. If just one, then it is returned. The merged namespace symbol may hold onto the array. A namespace symbol representing the merged namespace.(of /returns) Create a possibly merged namespace symbol representing global namespace on a compilation level. Create a possibly merged namespace symbol (namespace group). If only a single namespace is passed it, it is just returned directly. If two or more namespaces are passed in, then a new merged namespace is created One or more namespaces to merged. If just one, then it is returned. The merged namespace symbol may hold onto the array. A namespace symbol representing the merged namespace.(of /returns) Create a possibly merged namespace symbol (namespace group). If only a single namespace is passed it, it is just returned directly. If two or more namespaces are passed in, then a new merged namespace is created with the given extent and container. The containing namespace to used, IF a merged namespace is created. One or more namespaces to merged. If just one, then it is returned. The merged namespace symbol may hold onto the array. A namespace symbol representing the merged namespace.(of /returns) Method that is called from the CachingLookup to lookup the children of a given name. Looks in all the constituent namespaces. Method that is called from the CachingLookup to get all child names. Looks in all constituent namespaces. Calculate declared accessibility of most accessible type within this namespace or within a containing namespace recursively. Expected to be called at most once per namespace symbol, unless there is a race condition. Valid return values: Friend, Public, NotApplicable - if there are no types. For test purposes only. Returns true if namespace contains types accessible from the target assembly. Populate the map with all extension methods declared within this namespace, so that methods from the same type are grouped together within each bucket. Represents source or metadata assembly. An array of cached Cor types defined in this assembly. Lazily filled by GetSpecialType method. How many Cor types have we cached so far. Lookup declaration for predefined CorLib type in this Assembly. Only should be called if it is know that this is the Cor Library (mscorlib). Register declaration of predefined CorLib type in this Assembly. Continue looking for declaration of predefined CorLib type in this Assembly while symbols for new type declarations are constructed. Determine whether this assembly has been granted access to . Assumes that the public key has been determined. The result will be cached. Lazy cache of special members. Not yet known value is represented by ErrorTypeSymbol.UnknownResultType Lookup member declaration in predefined CorLib type in this Assembly. Only valid if this assembly is the Cor Library Helper methods that exist to share code between properties and events. One of the methods has more parameters than the other AND at least one of the extra parameters is NOT optional One of the methods has more parameters than the other AND at least one of the extra parameters IS optional OR there is at least one parameter in one method with optionality (being optional or required) not equal to that of the matching parameter from the other method Taken into consideration only if is set. Mismatch in total number of parameters, both required and optional Implementation of IEqualityComparer for MethodSymbols, with options for various aspects to compare. This instance is intended to reflect the definition of signature equality used by the runtime (ECMA 335 Section 8.6.1.6). It considers return type, name, parameters, calling convention, and custom modifiers. This instance is used to compare all aspects. This instance is used to compare parameter and return types, including byref. This instance is used to compare custom modifiers, parameter and return types, including byref. This instance is used to search for methods that have the same signature, return type, and constraints according to the VisualBasic definition. Custom modifiers are ignored. This instance is used to search for methods that have identical signatures in every regard. This instance is used to compare potential WinRT fake methods in type projection. FIXME(angocke): This is almost certainly wrong. The semantics of WinRT conflict comparison should probably match overload resolution (i.e., we should not add a member to lookup that would result in ambiguity), but this is closer to what Dev12 does. The real fix here is to establish a spec for how WinRT conflict comparison should be performed. Once this is done we should remove these comments. Returns true if the first set of constraint types is a subset of the second set. Determines if the method can be called with empty parameter list. The method. Determines if the method is partial The method Determines if the method is partial and does NOT have implementation provided The method Is method a user-defined operator. Returns a constructed method symbol if 'method' is generic, otherwise just returns 'method' A is a special kind of that represents an assembly that couldn't be found. AssemblySymbol to represent missing, for whatever reason, CorLibrary. The symbol is created by ReferenceManager on as needed basis and is shared by all compilations with missing CorLibraries. An array of cached Cor types defined in this assembly. Lazily filled by GetDeclaredSpecialType method. Lookup declaration for predefined CorLib type in this Assembly. Only should be called if it is know that this is the Cor Library (mscorlib). A MissingMetadataSymbol is a special kind of ErrorSymbol that represents a type symbol that was attempted to be read from metadata, but couldn't be found, because: a) The metadata file it lives in wasn't referenced b) The metadata file was referenced, but didn't contain the type c) The metadata file was referenced, contained the correct outer type, but didn't contains a nested type in that outer type. Represents not nested missing type. SpecialType.TypeId This is the FULL namespace name (e.g., "System.Collections.Generic") of the type that couldn't be found. Represents nested missing type. A is a special kind of that represents a module that couldn't be found. A is a special kind of that represents a namespace that couldn't be found. Represents a module within an assembly. Every assembly contains one or more modules. Module's ordinal within containing assembly's Modules array. 0 - for a source module, etc. -1 - for a module that doesn't have containing assembly, or has it, but is not part of Modules array. Target architecture of the machine. Indicates that this PE file makes Win32 calls. See CorPEKind.pe32BitRequired for more information (http://msdn.microsoft.com/en-us/library/ms230275.aspx). Returns a NamespaceSymbol representing the global (root) namespace, with module extent, that can be used to browse all of the symbols defined in this module. Returns the containing assembly. Modules are always directly contained by an assembly, so this property always returns the same as ContainingSymbol. Returns an array of assembly identities for assemblies referenced by this module. Items at the same position from ReferencedAssemblies And from ReferencedAssemblySymbols correspond to each other. If this symbol represents a metadata module returns the underlying . Otherwise, this returns . Returns an array of assembly identities for assemblies referenced by this module. Items at the same position from GetReferencedAssemblies and from GetReferencedAssemblySymbols should correspond to each other. The array and its content is provided by ReferenceManager and must not be modified. Returns an array of AssemblySymbol objects corresponding to assemblies referenced by this module. Items at the same position from ReferencedAssemblies And from ReferencedAssemblySymbols correspond to each other. Returns an array of AssemblySymbol objects corresponding to assemblies referenced by this module. Items at the same position from GetReferencedAssemblies and from GetReferencedAssemblySymbols should correspond to each other. If reference is not resolved by compiler, GetReferencedAssemblySymbols returns MissingAssemblySymbol in the corresponding item. The array and its content is provided by ReferenceManager and must not be modified. A helper method for ReferenceManager to set assembly identities for assemblies referenced by this module and corresponding AssemblySymbols. A description of the assemblies referenced by this module. Source assembly that triggered creation of this module symbol. For debug purposes only, this assembly symbol should not be persisted within this module symbol because the module can be shared across multiple source assemblies. This method will only be called for the first one. True if this module has any unified references. Returns a unification use-site error (if any) for a symbol contained in this module that is referring to a specified . If an assembly referenced by this module isn't exactly matching any reference given to compilation the Assembly Manager might decide to use another reference if it matches except for version (it unifies the version with the existing reference). Lookup a top level type referenced from metadata, names should be compared case-sensitively. Full type name possibly with generic name mangling. Symbol for the type, or Nothing if the type isn't found. Returns true if there is any applied CompilationRelaxationsAttribute assembly attribute for this module. Returns true if there is any applied RuntimeCompatibilityAttribute assembly attribute for this module. Default char set for contained types, or null if not specified. Determined based upon value specified via applied on this module. Given a namespace symbol, returns the corresponding module specific namespace symbol Does this symbol represent a missing Module. If this property returns false, it is certain that there are no extension methods (from language perspective) inside this module. If this property returns true, it is highly likely (but not certain) that this type contains extension methods. This property allows the search for extension methods to be narrowed much more quickly. !!! Note that this property can mutate during lifetime of the symbol !!! !!! from True to False, as we learn more about the module. !!! Safe to call on a null reference. Given a name, find a member field or property (ignoring all other members) in a type. Given a possibly constructed/specialized generic type, create a symbol representing an unbound generic type for its definition. A NamespaceExtent represents whether a namespace contains types and sub-namespaces from a particular module, assembly, or merged across all modules (source and metadata) in a particular compilation. Returns what kind of extent: Module, Assembly, or Compilation. If the Kind is ExtendKind.Module, returns the module symbol that this namespace encompasses. Otherwise throws InvalidOperationException. If the Kind is ExtendKind.Assembly, returns the assembly symbol that this namespace encompasses. Otherwise throws InvalidOperationException. If the Kind is ExtendKind.Compilation, returns the compilation symbol that this namespace encompasses. Otherwise throws InvalidOperationException. Create a NamespaceExtent that represents a given ModuleSymbol. Create a NamespaceExtent that represents a given AssemblySymbol. Create a NamespaceExtent that represents a given Compilation. Represents either a namespace or a type. Returns true if this symbol is a namespace. If its not a namespace, it must be a type. Returns true if this symbols is a type. Equivalent to Not IsNamespace. Get all the members of this symbol. An ImmutableArray containing all the members of this symbol. If this symbol has no members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol. The members may not be in a particular order, and the order may not be stable from call-to-call. An ImmutableArray containing all the members of this symbol. If this symbol has no members, returns an empty ImmutableArray. Never returns null. Get all the members of this symbol that have a particular name. An ImmutableArray containing all the members of this symbol with the given name. If there are no members with this name, returns an empty ImmutableArray. The result is deterministic (i.e. the same from call to call and from compilation to compilation). Members of the same kind appear in the result in the same order in which they appeared at their origin (metadata or source). Never returns Nothing. Get all the type members of this symbol. The types may not be in a particular order, and the order may not be stable from call-to-call. An ImmutableArray containing all the type members of this symbol. If this symbol has no type members, returns an empty ImmutableArray. Never returns null. Get all the members of this symbol that are types. An ImmutableArray containing all the types that are members of this symbol. If this symbol has no type members, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types that have a particular name, and any arity. An ImmutableArray containing all the types that are members of this symbol with the given name. If this symbol has no type members with this name, returns an empty ImmutableArray. Never returns Nothing. Get all the members of this symbol that are types that have a particular name and arity. An ImmutableArray containing all the types that are members of this symbol with the given name and arity. If this symbol has no type members with this name and arity, returns an empty ImmutableArray. Never returns Nothing. Returns true if this symbol was declared as requiring an override; i.e., declared with the "MustOverride" modifier. Never returns true for types. Always returns False. Returns true if this symbol was declared to override a base class members and was also restricted from further overriding; i.e., declared with the "NotOverridable" modifier. Never returns true for types. Always returns False. Returns true if this member is overridable, has an implementation, and does not override a base class member; i.e., declared with the "Overridable" modifier. Does not return true for members declared as MustOverride or Overrides. Always returns False. Returns true if this symbol was declared to override a base class members; i.e., declared with the "Overrides" modifier. Still returns true if the members was declared to override something, but (erroneously) no member to override exists. Always returns False. This is a helper method shared between NamedTypeSymbol and NamespaceSymbol. Its purpose is to add names of probable extension methods found in membersByName parameter to nameSet parameter. Method's viability check is delegated to overridable method AddExtensionMethodLookupSymbolsInfoViabilityCheck, which is overridden by RetargetingNamedtypeSymbol and RetargetingNamespaceSymbol in order to perform the check on corresponding RetargetingMethodSymbol. Returns true if there were extension methods among the members, regardless whether their names were added into the set. Perform extension method viability check within AppendExtensionMethodNames method above. This method is overridden by RetargetingNamedtypeSymbol and RetargetingNamespaceSymbol in order to perform the check on corresponding RetargetingMethodSymbol. Returns true if the method is viable. Finds types or namespaces described by a qualified name. Sequence of simple plain names. A set of namespace or type symbols with given qualified name (might comprise of types with multiple generic arities), or an empty set if the member can't be found (the qualified name is ambiguous or the symbol doesn't exist). "C.D" matches C.D, C(Of T).D, C(Of S,T).D(Of U), etc. A is a special kind of that represents an assembly that is not missing, i.e. the "real" thing. This is a cache similar to the one used by MetaImport::GetTypeByName in native compiler. The difference is that native compiler pre-populates the cache when it loads types. Here we are populating the cache only with things we looked for, so that next time we are looking for the same thing, the lookup is fast. This cache also takes care of TypeForwarders. Gives about 8% win on subsequent lookups in some scenarios. The global namespace symbol. Lazily populated on first access. Does this symbol represent a missing assembly. Gets the merged root namespace that contains all namespaces and types defined in the modules of this assembly. If there is just one module in this assembly, this property just returns the GlobalNamespace of that module. Lookup a top level type referenced from metadata, names should be compared case-sensitively. Full type name, possibly with generic name mangling. Lookup a top level type referenced from metadata, names should be compared case-sensitively. Detect cycles during lookup. Full type name, possibly with generic name mangling. List of assemblies lookup has already visited (since type forwarding can introduce cycles). For test purposes only. For test purposes only. A is a special kind of that represents a module that is not missing, i.e. the "real" thing. An array of objects corresponding to assemblies directly referenced by this module. The contents are provided by ReferenceManager and may not be modified. Does this symbol represent a missing Module. Returns an array of assembly identities for assemblies referenced by this module. Items at the same position from GetReferencedAssemblies and from GetReferencedAssemblySymbols should correspond to each other. The array and its content is provided by ReferenceManager and must not be modified. Returns an array of AssemblySymbol objects corresponding to assemblies referenced by this module. Items at the same position from GetReferencedAssemblies and from GetReferencedAssemblySymbols should correspond to each other. If reference is not resolved by compiler, GetReferencedAssemblySymbols returns MissingAssemblySymbol in the corresponding item. The array and its content is provided by ReferenceManager and must not be modified. A helper method for ReferenceManager to set assembly identities for assemblies referenced by this module and corresponding AssemblySymbols. Lookup a top level type referenced from metadata, names should be compared case-sensitively. Full type name, possibly with generic name mangling. Symbol for the type, or Nothing if the type isn't found. A NoPiaAmbiguousCanonicalTypeSymbol is a special kind of ErrorSymbol that represents a NoPia embedded type symbol that was attempted to be substituted with canonical type, but the canonical type was ambiguous. A NoPiaIllegalGenericInstantiationSymbol is a special kind of ErrorSymbol that represents a generic type instantiation that cannot cross assembly boundaries according to NoPia rules. A NoPiaMissingCanonicalTypeSymbol is a special kind of ErrorSymbol that represents a NoPia embedded type symbol that was attempted to be substituted with canonical type, but the canonical type couldn't be found. Initialize the ObsoleteAttributeData by fetching attributes and decoding ObsoleteAttributeData. This can be done for Metadata symbol easily whereas trying to do this for source symbols could result in cycles. This method checks to see if the given symbol is Obsolete or if any symbol in the parent hierarchy is Obsolete. True if some symbol in the parent hierarchy is known to be Obsolete. Unknown if any symbol's Obsoleteness is Unknown. False, if we are certain that no symbol in the parent hierarchy is Obsolete. Create a diagnostic for the given symbol. This could be an error or a warning based on the ObsoleteAttribute's arguments. Groups the information computed by MakeOverriddenMembers. In C# this class also stores hidden members (and is named OverriddenOrHiddenMembersResult). The way VB warns on hidden members, this did not turn out to be useful. Expected to be a member symbol type (e.g. method, property). The member(s) that are potentially being overridden. This collection only contains candidates having signature 'exactly' matching the signature of the method/property. 'Exact' signature match is defined as 'general' signature match plus NO mismatches in total number of parameters or optional parameter types. See comments on InaccessibleMembers for more details on 'general' signature match. The member(s) that are potentially being overridden. This collection only contains candidates having signature 'generally' matching the signature of the method/property. Two signatures 'generally' match if DetailedSignatureCompare (...) returns no mismatches defined in SymbolComparisonResults.AllMismatches ignoring mismatches grouped in SymbolComparisonResults.MismatchesForConflictingMethods. Members that would be in OverriddenMembers if they were accessible. It is not suitable to call this method on a object associated with a member within substituted type, should be used instead. Represents a namespace. For a given namespace in context of a particular Compilation all binders use either a compilation merged namespace symbol, or a module level namespace symbol (PE, Source or Retargeting). In order to speed-up lookup of extension methods performed by a binder, we build and cache a map of all extension methods declared within the namespace grouped by name (case-insensitively). If binder uses compilation merged namespace symbol, the map is built across all underlying module level namespace symbols, separate maps for underlying namespace symbols are not built. If binder uses Retargeting module level namespace symbol, we build the map for the underlying namespace symbol instead and push all requests through the underlying namespace. The map actually stores ImmutableArray(Of MethodSymbol), but we are using ImmutableArray(Of Symbol) in order to be able to pass the map to a more general API. Returns declared accessibility of most accessible type within this namespace or within a containing namespace recursively. Valid return values: Friend, Public, NotApplicable - if there are no types. This is an entry point for the Binder to collect extension methods with the given name declared within this (compilation merged or module level) namespace, so that methods from the same type are grouped together. A cached map of extension methods is used to optimize the lookup. Add names of viable extension methods declared in this (compilation merged or module level) namespace to nameSet parameter. The 'appendThrough' parameter allows RetargetingNamespaceSymbol to delegate majority of the work to the underlying namespace symbol, but still perform viability check on RetargetingMethodSymbol. A cached map of extension methods is used to optimize the operation. Build and cache a map of probable extension methods for this namespace. An error type symbol to represent a pointer type. Pointer types are not supported by VB language, but internally we need to be able to match them in signatures of methods imported from metadata. Represents a preprocessing conditional compilation symbol. Implementation of IEqualityComparer for PropertySymbols, with options for various aspects to compare. This instance is intended to reflect the definition of signature equality used by the runtime (ECMA 335 Section 8.6.1.6). It considers type, name, parameters, and custom modifiers. This instance is used to search for properties that have identical signatures in every regard. This instance is used to compare potential WinRT fake properties in type projection. FIXME(angocke): This is almost certainly wrong. The semantics of WinRT conflict comparison should probably match overload resolution (i.e., we should not add a member to lookup that would result in ambiguity), but this is closer to what Dev12 does. The real fix here is to establish a spec for how WinRT conflict comparison should be performed. Once this is done we should remove these comments. Determines if the property can be accessed with empty parameter list. The property. Represents a curried extension method definition - first parameter and fixed type parameters removed. If this is an extension method that can be applied to an instance of the given type, returns the curried method symbol thus formed. Otherwise, returns Nothing. Represents type parameter of a curried extension method definition. Represents parameter of a curried extension method definition. A representation of a method symbol that is intended only to be used for comparison purposes (esp in MethodSignatureComparer). Intended to be used to create ParameterSymbols for a SignatureOnlyMethodSymbol. A representation of a property symbol that is intended only to be used for comparison purposes (esp in PropertySignatureComparer). Represents a Lambda parameter for a LambdaSymbol. Type parameters in documentation comments are complicated since they sort of act as declarations, rather than references. Like in the following example: ''' Class Clazz ... We're going to ignore SourceMemberFlags.MethodIsSub and override IsSub explicitly. We do this because the flags have to be set at construction time, but IsSub depends on IsWindowsRuntimeEvent, which depends on interface implementations, which we don't want to bind until the member list is complete. (It's probably okay now (2012/12/17), but it would be very fragile to take a dependency on the exact mechanism by which interface members are looked up.) Bind and validate parameters declared on the accessor. sourceMethod has the custom modifiers sourceType has the custom modifiers Returns True if was modified. Attribute location corresponding to this symbol. Location of an attribute if an explicit location is not specified via attribute target specification syntax. Methods, Properties, and Events all have implements clauses and need to handle interface implementation. This module has helper methods and extensions for sharing by multiple symbol types. Find the implemented method denoted by "implementedMemberSyntax" that matches implementingSym. Returns the implemented method, or Nothing if none. Also stores into "candidateSymbols" (if not Nothing) and resultKind the symbols and result kind that should be used for semantic model purposes. Does 'implementingSym' match 'implementedSym' well enough to be considered a match for interface implementation? Perform additional validate of implementedSym and issue diagnostics. Return "implementedSym" if the symbol table should record implementedSym as the implemented symbol (even if diagnostics were issues). Returns Nothing if the code should not treat implementedSym as the implemented symbol. Validate method type parameter constraints. This is handled outside of ValidateImplementedMember because that method is invoked while computing the ExplicitInterfaceImplementations value on the implementing method, but method type parameters rely on the value of ExplicitInterfaceImplementations to determine constraints correctly. Performs interface mapping to determine which symbol in this type or a base type actually implements a particular interface member. MethodSymbol or PropertySymbol or EventSymbol (an interface member). A non-null member on an interface type. The type implementing the interface member. A comparer for comparing signatures of TSymbol according to metadata implementation rules. The implementing member or Nothing, if there isn't one. Search the declared methods of a type for one that could be an implicit implementation of a given interface method (depending on interface declarations). It is assumed that the implementing type is not a source type. MethodSymbol or PropertySymbol or EventSymbol (an interface member). The interface member being implemented. The type on which we are looking for a declared implementation of the interface method. A comparer for comparing signatures of TSymbol according to metadata implementation rules. Given a set of explicit interface implementations that are undergoing substitution, return the substituted versions. Type of the interface members (Method, Property, Event) The ROA of members that are being implemented The type substitution The substituted members. Represents implicit, script and submission classes. Represents a Lambda parameter. Represents a method symbol for a lambda method. This symbol is used as the return type of a LambdaSymbol when we are interpreting lambda's body in order to infer its return type. This symbol is used as the return type of a LambdaSymbol when we failed to infer lambda's return type, but still want to interpret its body. This symbol is used as the return type of a LambdaSymbol when we are dealing with query lambda and the return type should be taken from the target delegate upon successful conversion. The LambdaSymbol will be mutated then. This symbol is used as the return type of a LambdaSymbol when System.Void is used in code. This symbol is used as a sentinel while we are binding a lambda in error recovery mode. Can mutate for a query lambda from ReturnTypePendingDelegate to the return type of the target delegate. "Me" parameter for this lambda will be that of the containing symbol Specifies the syntax that a user defined variable comes from. The local is not user defined nor it is a copy of a user defined local (e.g. with a substituted type). Check the value of for the kind of synthesized variable. Implicitly declared variable (w/o variable declaration). Only used in flow analysis for the pseudo-local representing a symbol of the implicit receiver in case Dim statement defines more than one variable, but uses the same object initializer for all of them, like in: Dim a,b As New C() With { .X = .Y } Represents a local variable (typically inside a method body). This could also be a local variable implicitly declared by a For, Using, etc. When used as a temporary variable, its container can also be a Field or Property Symbol. Create a local symbol from a local variable declaration. Create a local symbol associated with an identifier token. Create a local symbol associated with an identifier token and a different name. Used for WinRT event handler return value variable). Create a local symbol with substituted type. Create an inferred local symbol from a For from-to statement. Create an inferred local symbol from a For-each statement. Create a local variable symbol. Note: this does not insert it automatically into a local binder so that it can be found by lookup. Returns true if this local is a ReadOnly local. Compiler has a concept of ReadOnly locals. Returns the syntax node that declares the variable. All user-defined and long-lived synthesized variables must return a reference to a node that is tracked by the EnC diffing algorithm. For example, for variable the declarator is the node, not the that immediately contains the variable. The location of the declarator is used to calculate during emit. Was this local variable implicitly declared, because Option Explicit Off was in effect, and no other symbol was found with this name. Returns data decoded from Obsolete attribute or null if there is no Obsolete attribute. This property returns ObsoleteAttributeData.Uninitialized if attribute arguments haven't been decoded yet. Base class for any local symbol that can be referenced in source, might be implicitly declared. Class for a local symbol that has a different name than the identifier token. In this case the real name is returned by the name property and the "VB User visible name" can be obtained by accessing the IdentifierToken. Create a local variable symbol. Note: this does not insert it automatically into a local binder so that it can be found by lookup. A local symbol created by a for-each statement when Option Infer is on. Create a local variable symbol. Note: this does not insert it automatically into a local binder so that it can be found by lookup. A local symbol created by For from-to statement when Option Infer is on. Create a local variable symbol. Note: this does not insert it automatically into a local binder so that it can be found by lookup. A local symbol created from a variable declaration or a for statement with an as clause. Create a local variable symbol. Note: this does not insert it automatically into a local binder so that it can be found by lookup. Local symbol that is not associated with any source. Generally used for temporary locals past the initial binding phase. Function that help implement the overloading rules for VB, in particular the rules for recasing method and property names. Set the correct metadata name for all overloads of a particular name and symbol kind (must be method or property) inside a container. The rules are as follows: 1) If a method or property overrides one from its base class, its metadata name must match that. 2) If method overloads those in the base (because the Overloads keyword is used), and all metadata names in the base are consistent in case, use that name. 3) All overloads with a class should match, except possibly for overrides. If there is an override or overload from base, use that. Otherwise, use casing of first member in class. Collect all overloads in "container" of the given name and kind. Also determine if any have "Overloads" or "Overrides" specifiers. For each member in "overloadedMembers" that is marked Overrides, set its metadata name to be the metadata name of its overridden member. Return the first such name, lexically. Note: can return null if no override member with an actual overridden member was found. Return the name of the lexically first symbol in "overloadedMembers". Check all accessible, visible members of the base types of container for the given name and kind. If they all have the same case-sensitive metadata name, return that name. Otherwise, return Nothing. Methods, Properties, and Events all can override or hide members. This class has helper methods and extensions for sharing by multiple symbol types. Check for overriding and hiding errors in container and report them via diagnostics. Containing type to check. Should be an original definition. Place diagnostics here. Check each member of container for constraints against the base type. For methods and properties and events, checking overriding and hiding constraints. For other members, just check for hiding issues. Containing type to check. Should be an original definition. Place diagnostics here. If the "container" is a non-MustInherit, make sure it has no MustOverride Members If "container" is a non-MustInherit inheriting from a MustInherit, make sure that all MustOverride members have been overridden. If "container" is a MustInherit inheriting from a MustInherit, make sure that no MustOverride members have been shadowed. Report any diagnostics related to shadowing for a member. Some symbols do not participate in overriding/hiding (e.g. constructors). Accessors are consider to override or hide. If a method had a virtual inaccessible override, then an explicit override in metadata is needed to make it really override what it intends to override, and "skip" the inaccessible virtual method. Many of the methods want to generically work on properties, methods (and maybe events) as TSymbol. We put all these methods into a generic class for convenience. Walk up the type hierarchy from ContainingType and list members that this method overrides (accessible methods/properties with the same signature, if this method is declared "override"). Methods in the overridden list may not be virtual or may have different accessibilities, types, accessors, etc. They are really candidates to be overridden. All found accessible candidates of overridden members are collected in two builders, those with 'exactly' matching signatures and those with 'generally' or 'inexactly' matching signatures. 'Exact' signature match is a 'general' signature match which also does not have mismatches in total number of parameters and/or types of optional parameters. See also comments on correspondent OverriddenMembersResult(Of TSymbol) properties. 'Inexactly' matching candidates are only collected for reporting Dev10/Dev11 errors like BC30697 and others. We collect 'inexact' matching candidates until we find any 'exact' match. Also remembers inaccessible members that are found, but these do not prevent continuing to search for accessible members. In the presence of non-VB types, the meaning of "same signature" is rather complicated. If this method isn't from source, then it refers to the runtime's notion of signature (i.e. including return type, custom modifiers, etc). If this method is from source, use the VB version of signature. Note that Dev10 C# has a rule that prefers members with less custom modifiers. Dev 10 VB has no such rule, so I'm not adding such a rule here. Look for overridden members in a specific type. Return true if we find an overridden member candidate with 'exact' signature match, or we hit a member that hides. See comments on MakeOverriddenMembers(...) for description of 'exact' and 'inexact' signature matches. Also remember any inaccessible members that we see. Syntax that overriding or hiding. True if "overridingSym" is from source (this.IsFromSomeCompilation). The type that contains this method (this.ContainingType). The type to search. Builder to place exactly-matched overridden member candidates in. Builder to place inexactly-matched overridden member candidates in. Builder to place exactly-matched inaccessible overridden member candidates in. The QuickAttributeChecker applies a simple fast heuristic for determining probable attributes without binding attribute types, just by looking at the final syntax of an attribute usage. It is accessed via the QuickAttributeChecker property on Binder. It works by maintaining a dictionary of all possible simple names that might map to a particular attribute. Add a mapping from name to some attributes. Process an alias clause and any imported mappings from it. E.g., If you have an alias Ex=Blah.Extension, add any mapping for Extension to those for Ex. Note that although, in VB, an alias cannot reference another alias, this code doesn't not attempt to distinguish between aliases and regular names, as that would add complexity to the data structure and would be unlikely to matter. This entire class is probabilistic anyone and is only used for quick checks. Check attribute lists quickly to see what attributes might be referenced. Indicate which attributes might be present. Could be extended to other attributes if desired. Returns the that corresponds to the particular type passed in. If Is then the name will be checked both as-Is as well as with the 'Attribute' suffix. Represents a range variable symbol. Create a range variable symbol associated with an identifier token. Create a range variable symbol not associated with an identifier token, i.e. with illegal name. Used for error recovery binding. Represents a source parameter cloned from another , when they must share attribute data. For example, parameters on delegate Invoke method are cloned to delegate BeginInvoke, EndInvoke methods. Represents a parameter symbol defined in source. Symbol to copy bound attributes from, or null if the attributes are not shared among multiple source method symbols. Used for partial method parameters: Implementation parameter always copies its attributes from the corresponding definition parameter. Definition is always complex parameter and so it stores the attribute bag. Is parameter explicitly declared ByRef. Can be different from IsByRef only for String parameters of Declare methods. Represents a declare method defined in source. This class represent a compiler generated method of a delegate type that is based upon source delegate or event delegate declaration. Returns true if this method is an extension method. Gets a value indicating whether this instance is external method. true if this instance is external method; otherwise, false. Get the type parameters on this method. If the method has not generic, returns an empty list. Gets a value indicating whether the symbol was generated by the compiler rather than declared explicitly. Represents enum constant field in source. Indicates whether event created a new delegate type. In such case the Type must be added to the members of the containing type Unless the type is inferred, check that all implemented events have the same type. Helper method for accessors to get the overridden accessor methods. Should only be called by the accessor method symbols. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. NOTE: This method should always be kept as a NotOverridable method. If you want to override attribute binding logic for a sub-class, then override method. See Gets the syntax tree. Field initializer's declaration syntax node. It can be a EqualsValueSyntax or AsNewClauseSyntax. Gets a value indicating whether this instance has declared type. This means not an inferred type. true if this instance has declared type; otherwise, false. Gets the constant value. Used to detect dependencies between constant field values. Helper to get a constant value of the field with cycle detection. Also avoids deep recursion due to references to other constant fields in the value. Derived types utilizing this helper should provide storage for the lazily calculated value and should implement the following APIs: , , . Generate a list containing the field and all dependencies of that field that require evaluation. The list is ordered by dependencies, with fields with no dependencies first. Cycles are broken at the first field lexically in the cycle. If multiple threads call this method with the same field, the order of the fields returned should be the same, although some fields may be missing from the lists in some threads as other threads evaluate fields. The set of fields on which the field depends. The set of fields that depend on the field. Build a dependency graph (a map from field to dependencies). Return the constant value dependencies. Compute the dependencies if necessary by evaluating the constant value but only persist the constant value if there were no dependencies. (If there are dependencies, the constant value will be re-evaluated after evaluating dependencies.) Should be overridden by types utilizing helper. Should be overridden by types utilizing helper. Should be overridden by types utilizing helper. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. NOTE: This method should always be kept as a NotOverridable method. If you want to override attribute binding logic for a sub-class, then override method. Verify the constant value matches the default value from any earlier attribute (DateTimeConstantAttribute or DecimalConstantAttribute). If not, report ERR_FieldHasMultipleDistinctConstantValues. The bound information from a file. Data for Binder.BindImportClause that maintains flat lists of members and member syntax references in addition to the dictionaries needed by BindImportClause. Perform any validation of import statements that must occur after the import statements have been added to the SourceFile. Specifically, constraints are checked for generic type references. Return the member imports for this file. Doesn't contain error types. Return the alias imports for this file. May return Nothing if there are no alias imports. May contain aliases with error type targets. Return the xmlns imports for this file. May return Nothing if there are no xmlns imports. Returns the value of the Option Strict declaration if there was one, otherwise Null. Returns the value of the Option Infer declaration if there was one, otherwise Null. Returns the value of the Option Explicit declaration if there was one, otherwise Null. Returns the value of the Option Compare Text/Binary declaration if there was one, otherwise Null. True means Text, False means Binary. Force all declaration errors to be generated. Get all declaration errors in the given filterSpan. Represents a named type symbol whose members are declared in source. Holds information about a SourceType in a compact form. Compute the type flags from the declaration. This function DOES NOT diagnose errors in the modifiers. Given the set of modifiers, it produces the flags, even in the case of potentially conflicting modifiers. We have to return some answer even in the case of errors. Force all declaration errors to be generated. Following enum is used just to help give more specific error messages. Ensure all attributes on all members in the named type are bound. Should return full emitted namespace name for a top level type if the name might be different in case from containing namespace symbol full name, Nothing otherwise. Although namespaces unify based on case-insensitive name, VB uses the casing the namespace declaration surround the class definition for the name emitted to metadata. Namespace GOO Class X End Class ENd Namespace Namespace goo Class Y End Class ENd Namespace In metadata, these are classes "GOO.X" and "goo.Y" (and thus appear in different namespaces when imported into C#.) This function determines the casing of the namespace part of a class, if needed to override the namespace name. Syntax references of all parts of the type declaration. Submission and script classes are represented by their containing , implicit class can be represented by or . Structure to wrap the different arrays of members. Initializes a new instance of the class. The members. The static initializers. The instance initializers. Accumulates different members kinds used while building the members. Adds a field initializer for the field to list of field initializers All initializers. Compute the field initializer to add to the list of initializers. Adds an array of initializers to the member collections structure All initializers. The siblings. Examines the members collection and builds a set of partial methods if any, otherwise returns nothing Compares two methods to check if the 'candidate' can be an implementation of the 'partialDeclaration'. Poolable data set to be used in structure circularity detection. Following C# implementation we keep up to 32 data sets so that we do not need to allocate them over and over. In this implementation though, circularity detection in one type can trigger circularity detection in other types while it traverses the types tree. The traversal is being performed breadth-first, so the number of data sets used by one thread is not longer than the length of the longest structure-in-structure nesting chain. Set of processed structure types Queue element structure Queue of the types to be processed Analyzes structure type for circularities. Reports only errors relevant for 'structBeingAnalyzed' type. When VB Dev10 detects circularity it reports the error only once for each cycle. Thus, if the cycle is {S1 --> S2 --> S3 --> S1}, only one error will be reported, which one of S1/S2/S3 will have error is non-deterministic (depends on the order of symbols in a hash table). Moreover, Dev10 analyzes the type graph and reports only one error in case S1 --> S2 --> S1 even if there are two fields referencing S2 from S1. Example: Structure S2 Dim s1 As S1 End Structure Structure S3 Dim s1 As S1 End Structure Structure S1 Dim s2 As S2 ' ERROR Dim s2_ As S2 ' NO ERROR Dim s3 As S3 ' ERROR End Structure Dev10 also reports only one error for all the cycles starting with the same field, which one is reported depends on the declaration order. Current implementation reports all of the cycles for consistency. See testcases MultiplyCyclesInStructure03 and MultiplyCyclesInStructure04 (report different errors in Dev10). Simple check of whether or not we should step into the type 'typeToTest' during type graph traversal inside 'DetectStructureCircularity' or 'GetDependenceChain'. The following rules are in place: (a) we order all symbols according their first source location comparison rules: first, source file names are compared, then SourceSpan.Start is used for symbols inside the same file; (b) given this order we enter the loop if only 'typeToTest' is 'less' than 'structBeingAnalyzed'; (c) we also always enter types from other modules !!! To be ONLY used in 'CheckStructureCircularity'. True if detect type circularity code should step into 'typeToTest' type Returns true if at least one of the elements of this list needs to be injected into a constructor because it's not a const or it is a const and it's type is either decimal or date. Non const fields always require a constructor, so this function should be called to determine if a synthesized constructor is needed that is not listed in members list. Performs a check for overloads/overrides/shadows conflicts, generates diagnostics. Check to see if we need a default instance|shared constructor, and if so, create it. NOTE: we only need a shared constructor if there are any initializers to be injected into it, we don't create a constructor otherwise. In this case we also ignore const fields which will still require to be injected, because in this case we don't see the constructor to be visible in symbol table. In case the passed initializers require a shared constructor, this method returns a new MethodSymbol instance for the shared constructor if there is not already an explicit shared constructor Gets the static initializers. Gets the instance initializers. Get a dictionary with all the explicitly implemented interface symbols declared on this type. key = interface method/property/event compared using , value = explicitly implementing methods/properties/events declared on this type (normally a single value, multiple in case of an error). Getting this property also ensures that diagnostics relating to interface implementation, overriding, hiding and overloading are created. Reports the overloads error for this type. The diagnostics. Returns True if memberList(memberIndex) is an operator. Also performs operator overloading validation and reports appropriate errors. See if any member in [memberList] starting with [memberIndex] conflict with [method], report appropriate error and return true. Check for two different diagnostics on the set of implemented interfaces: 1) It is invalid for a type to directly (vs through a base class) implement two interfaces that unify (i.e. are the same for some substitution of type parameters). 2) It is a warning to implement variant interfaces twice with type arguments that could cause ambiguity during method dispatch. Interface1 and Interface2 conflict for some type arguments. Report the correct error in the correct location. Interface1 and Interface2 have variable ambiguity. Report the warning in the correct location. Interface1 and Interface2 match except for their tuple names. Report the error in the correct location. Gets the inferred type of this const field from the initialization value. Used to detect dependencies between constant field values. A source field with an explicit initializer. In a declaration declaring multiple fields, such as "Dim a, b, c = d", this class is used for the first field only. (Other fields in the declaration are instances of SourceFieldSymbolSiblingInitializer.) A tuple consisting of the evaluated constant value and type A source field with an explicit initializer. In a declaration declaring multiple fields, such as "Dim a, b, c = d", this class is used for the fields other than the first. (The first field is an instance of SourceFieldSymbolWithInitializer.) An instance of this class holds a reference to the first field in the declaration and reuses the bound initializer from that field. Represents a method declared in source. If this symbol represents a partial method definition or implementation part, its other part (if any). This should be set, if at all, before this symbol appears among the members of its owner. The implementation part is not listed among the "members" of the enclosing type. If this flag is set this method will be ignored in duplicated signature analysis, see ERR_DuplicateProcDef1 diagnostics. Set after all diagnostics have been reported for this symbol. Validate method type parameter constraints against implemented methods. This method is to be called to assign implementation to a partial method. Base class for method symbols that are associated with some syntax and can receive custom attributes (directly or indirectly via another source symbol). Creates a method symbol for Declare Sub or Function. Decode the modifiers on a user-defined operator, reporting errors where applicable. Returns true if our diagnostics were used in the event that there were two threads racing. True if 'Shadows' is explicitly specified in method's declaration. True if 'Overloads' is explicitly specified in method's declaration. True if 'Overrides' is explicitly specified in method's declaration. True if 'Handles' is specified in method's declaration Return the location from syntax reference only. Bind the constraint declarations for the given type parameter. The caller is expected to handle constraint checking and any caching of results. Symbol to copy bound attributes from, or null if the attributes are not shared among multiple source method symbols. Used for example for event accessors. The "remove" method delegates attribute binding to the "add" method. The bound attribute data are then applied to both accessors. Symbol to copy bound return type attributes from, or null if the attributes are not shared among multiple source symbols. Used for property accessors. Getter copies its return type attributes from the property return type attributes. So far we only need to return . If we ever needed to return a we could implement an interface on those two types. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. Returns the list of attributes, if any, associated with the return type. Returns data decoded from early bound well-known attributes applied to the symbol or null if there are no applied attributes. Forces binding and decoding of attributes. Represents the primary module of an assembly being built by compiler. Owning assembly. Holds diagnostics not related to source code in any particular source file This override is essential - it's a base case of the recursive definition. Get the SourceFile object associated with a root declaration. Returns Nothing if the tree doesn't belong to the compilation. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. NOTE: This method should always be kept as a NotOverridable method. If you want to override attribute binding logic for a sub-class, then override method. Data for Binder.BindImportClause that maintains flat lists of members, aliases, and corresponding syntax references in addition to the dictionaries needed by BindImportClause. The syntax references, instances of GlobalImportInfo, are used later, when validating constraints, to generate Locations for constraint errors. Perform any validation of import statements that must occur after the import statements have been added to the module. Perform validation of an import statement that must occur after the statement has been added to the module. Specifically, constraints are checked for generic type references. Get all the declaration errors in a single tree. Get all the declaration errors. Atomically store value into variable, and store the diagnostics away for later retrieval. When this routine returns, variable is non-null. If this routine stored value into variable, then the diagnostic bag is saved away before the variable is stored and it returns True. Otherwise it returns False. Represents a type or module declared in source. Could be a class, structure, interface, delegate, enum, or module. Information for ComClass specific analysis and metadata generation, created once ComClassAttribute is encountered. Lazy CoClass type if the attribute is specified. Nothing if not. In case a cyclic dependency was detected during base type resolution this field stores the diagnostic. Bind the constraint declarations for the given type parameter. The caller is expected to handle constraint checking and any caching of results. 'Safe' version of GetDeclaredBase takes into account bases being resolved to make sure we avoid infinite loops in some scenarios. Note that the cycle is being broken not when we detect it, but when we detect it on the 'smallest' type of the cycle, this brings stability in multithreaded scenarios while still ensures that we don't loop more than twice. Do additional verification of base types the after acyclic base is found. This is the chance to generate diagnostics that may require walking bases and as such can be performed only after the base has been determined and cycles broken. (For instance, checking constraints on Class B(Of T) Inherits A(Of B(Of T)).) Do additional verification of interfaces after acyclic interfaces are found. This is the chance to generate diagnostics that may need to walk interfaces and as such can be performed only after the interfaces have been determined and cycles broken. (For instance, checking constraints on Class C(Of T) Implements I(Of C(Of T)).) Return the first Class declaration with explicit base classes to use for checking base class constraints. Other type declarations (Structures, Modules, Interfaces) are ignored since other errors will have been reported if those types include bases. Return the first Class, Structure, or Interface declaration with explicit interfaces to use for checking interface constraints. Other type declarations (Modules) are ignored since other errors will have been reported if those types include interfaces. For enum types, gets the underlying type. Returns null on all other kinds of types. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. Returns data decoded from early bound well-known attributes applied to the symbol or null if there are no applied attributes. Forces binding and decoding of attributes. Is System.Runtime.InteropServices.GuidAttribute applied to this type in code. Is System.Runtime.InteropServices.ClassInterfaceAttribute applied to this type in code. Is System.Runtime.InteropServices.ComSourceInterfacesAttribute applied to this type in code. Encapsulates ComClass specific data and analysis. Synthesized ComClass interfaces, can have the following values: Null - not yet initialized, Empty - there are no synthesized ComClass interfaces. one interface - only class interface is synthesized. two interfaces - both class interface and event interface are synthesized. Class interface is followed by the event interface. Returns symbol for the event interface or Nothing when event interface is not synthesized. Perform ComClass specific validation and prepare for metadata generation. Return False if ComVisibleAttribute(False) is applied to the symbol, True otherwise. Returns user defined DispId for a member or ReservedDispId.None if none specified. Also reports errors for reserved DispIds. Perform ComClass specific validation and prepare for metadata generation. Used to sort types - members of group collection. Register COR types declared in this namespace, if any, in the COR types cache. Gets the filename of the first declaration that matches the given namespace name case sensitively. Return the set of types that should be checked for presence of extension methods in order to build a map of extension methods for the namespace. Does this namespace have multiple different case-sensitive spellings (i.e., "Namespace GOO" and "Namespace goo". Includes parent namespace(s). Get the fully qualified namespace name using the spelling used in the declaration enclosing the given syntax tree and location. I.e., if this namespace was declared with: Namespace zAp Namespace GOO.bar 'location End Namespace End Namespace Namespace ZAP Namespace goo.bar End Namespace End Namespace It would return "ProjectNamespace.zAp.GOO.bar". Is this an accessor parameter that came from the associated property? If so, return it, else return Nothing. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. Verify the default value matches the default value from any earlier attribute (DefaultParameterValueAttribute, DateTimeConstantAttribute or DecimalConstantAttribute). If not, report ERR_ParamDefaultValueDiffersFromAttribute. Base class for all parameters that are emitted. Bind parameters declared on the accessor and combine with any parameters declared on the property. If there are no explicit parameters and this is a setter, create a synthesized value parameter. Property declaration syntax node. It is either PropertyStatement for normal properties or FieldDeclarationSyntax for WithEvents ones. Gets the attributes applied on this symbol. Returns an empty array if there are no attributes. NOTE: This method should always be kept as a NotOverridable method. If you want to override attribute binding logic for a sub-class, then override method. True if 'Overloads' is explicitly specified in method's declaration True if 'Overrides' is explicitly specified in method's declaration Helper method for accessors to get the overridden accessor methods. Should only be called by the accessor method symbols. True to get implemented getters, False to get implemented setters All the accessors of the given kind implemented by this property. Property declaration syntax node. It is either PropertyStatement for normal properties or ModifiedIdentifier for WithEvents ones. Return true if the accessor accessibility is more restrictive than the property accessibility, otherwise false. Returns the location (span) of the accessor begin block. (Used for consistency with the native compiler that highlights the entire begin block for certain diagnostics.) Report an error associated with the accessor accessibility modifier. Gets the syntax tree. Represents a parameters declared in source, that is not optional, does not have a default value, attributes, or is a ParamArray. This is a separate class to save memory, since there are LOTS of parameters. Represents a type parameter symbol defined in source. True if the redundant type parameter constraints should be reported as errors. For overridden methods, this is False since type substitution of type arguments for the base/interface may result in redundant constraints. This is a method rather than a property since the implementation may be expensive. Check constraints of generic types referenced in constraint types. For instance, with "Interface I(Of T As I(Of T))", check T satisfies constraints on I(Of T). Those constraints are not checked when binding ConstraintTypes since ConstraintTypes has not been set on I(Of T) at that point. Return the source location of the error, if any. If there error was from a constraint, and that constraint was from source, its location is returned. Otherwise if the type parameter was from source, its location is returned. If neither is from source, Nothing is returned. Represents a type parameter on a source type (as opposed to a method). Represents a type parameter on a source method (as opposed to a type). Represents a backing field of WithEvents property. Attributes applied on the property syntax are applied on the backing field. Represents a compiler generated backing field for an automatically implemented property. Represents an interactive code entry point that is inserted into the compilation if there is not an existing one. Generate a thread-safe accessor for a field-like event. DelegateType tmp0 = _event; //backing field DelegateType tmp1; DelegateType tmp2; do { tmp1 = tmp0; tmp2 = (DelegateType)Delegate.Combine(tmp1, value); //Remove for -= tmp0 = Interlocked.CompareExchange< DelegateType> (ref _event, tmp2, tmp1); } while ((object)tmp0 != (object)tmp1); Note, if System.Threading.Interlocked.CompareExchange<T> Is Not available, we emit the following code And mark the method Synchronized (unless it Is a struct). _event = (DelegateType)Delegate.Combine(_event, value); //Remove for -= Represents a compiler generated backing field for an event. System.NonSerializedAttribute applied on an event and determines serializability of its backing field. Represents a compiler generated field of given type and name. Represents a synthesized lambda. Gets a value indicating whether the symbol was generated by the compiler rather than declared explicitly. Represents a compiler generated "Main" sub. Represents a compiler "MyGroupCollection" property accessor. Represents a compiler generated field for a "MyGroupCollection" property. Represents a compiler "MyGroupCollection" property. Initializes a new instance of the class. The containing type for the synthesized constructor. if set to true if this is a shared constructor. WithEvents property accessor. Represents a Lambda parameter for an UnboundLambda. A SubstitutableTypeParameterSymbol represents a definition that is subject to alpha-renaming, which results in . The main purpose of this type is to share equality implementation that ensures symmetry across both of these types. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Represents a member variable (field) that has undergone type substitution. Represents a method that has undergone type substitution. This is use for a method inside a generic type that has undergone type substitution. It also serves as a base class for ConstructedMethodSymbol, which is used for a method after type substitution in the method type parameters. If this is a generic method return TypeSubstitution for it. TypeSubstitution for containing type otherwise. Compare with no regard to type arguments. Base class for symbols representing non-generic or open generic methods contained within constructed generic type. For example: A(Of Integer).B, A(Of Integer).B.C or A(Of Integer).B.C(Of ). Associate the method with a particular property. Returns false if the method is already associated with a property. Symbol representing non-generic method directly or indirectly contained within constructed generic type. For example: A(Of Integer).B or A(Of Integer).B.C Symbol representing open generic method directly or indirectly contained within constructed generic type. For example: A(Of Integer).B(Of ) or A(Of Integer).B.C(Of , ) Alpha-renamed type parameters, i.e. type parameters with constraints substituted according to containing type's TypeSubstitution. For example: Class A (Of T) Sub B(Of S As T)() End Sub End Class Given a method A(Of IComparable).B(Of ), alpha-renamed type parameter S will have type constraint IComparable. Base class for symbols representing constructed generic methods. For example: A(Of Integer), A.B(Of Integer), A(Of Integer).B.C(Of Integer). Symbols representing constructed generic method that is contained within constructed generic type. For example: A(Of Integer).B(Of Integer), A(Of Integer).B.C(Of Integer). Symbol for the ConstructedFrom method. A(Of Integer).B(Of ) for A(Of Integer).B(Of Integer), A(Of Integer).B.C(Of ) for A(Of Integer).B.C(Of Integer) All types in its containership hierarchy must be either constructed or non-generic, or original definitions. Symbols representing constructed generic method that isn't contained within constructed generic type. For example: A.B(Of Integer), but not A(Of Integer).B.C(Of Integer). A SubstitutedNamedType represents a named type that has had some sort of substitution applied to it. I.e., its not a pure instance type, but at least one type parameter in this type or a containing type has a substitution made for it. Type substitution for this symbol, it targets OriginalDefinition of the symbol. Base class for symbols representing non-generic or open generic types contained within constructed generic type. For example: A(Of Integer).B, A(Of Integer).B.C or A(Of Integer).B.C(Of ). Symbol for the containing type, either specialized or constructed. Symbol representing open generic type directly or indirectly contained within constructed generic type. For example: A(Of Integer).B(Of ) or A(Of Integer).B.C(Of , ) Alpha-renamed type parameters, i.e. type parameters with constraints substituted according to containing type's TypeSubstitution. For example: Class A (Of T) Class B(Of S As T) Dim x As A(Of Integer).B(Of S) 'error BC32044: Type argument 'S' does not inherit from or implement the constraint type 'Integer'. End Class End Class Given a type A(Of IComparable).B(Of ), alpha-renamed type parameter S will have type constraint IComparable. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Symbol representing non-generic type directly or indirectly contained within constructed generic type. For example: A(Of Integer).B or A(Of Integer).B.C Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Base class for symbols representing constructed generic types. For example: A(Of Integer), A.B(Of Integer), A(Of Integer).B.C(Of Integer). Symbols representing constructed generic type that isn't contained within another constructed generic type. For example: A(Of Integer), A.B(Of Integer), but not A(Of Integer).B.C(Of Integer). Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Symbols representing constructed generic type that is contained within another constructed generic type. For example: A(Of Integer).B(Of Integer), A(Of Integer).B.C(Of Integer). Symbol for the ConstructedFrom type. A(Of Integer).B(Of ) for A(Of Integer).B(Of Integer), A(Of Integer).B.C(Of ) for A(Of Integer).B.C(Of Integer) All types in its containership hierarchy must be either constructed or non-generic, or original definitions. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Force all declaration errors to be generated. Represents a parameter that has undergone type substitution. Represents a method parameter that has undergone type substitution. Represents a property parameter that has undergone type substitution. Represents a property that has undergone type substitution. A SubstitutedTypeParameterSymbol represents an alpha-renamed type parameter. They are created only for open generic types and methods that are contained within a constructed generic type. Alpha-renamed type parameters have their constraints substituted according to type/method's containing type's TypeSubstitution. For example: Class A (Of T) Class B(Of S As T) End Class End Class Given a type A(Of IComparable).B(Of ), alpha-renamed type parameter T will have type constraint IComparable. The rest will be exactly as for the original type parameter T. In fact, OriginalDefinition will return symbol for T. Containing type or method. The field is not read-only because it is initialized after construction through SetContainingSymbol() method. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Does the compilation this symbol belongs to output to a winmdobj? String such as 'class', 'interface' etc that can be used in error messages. String "ReadOnly", "WriteOnly", or "" describing the kind of property. Checks if there is a name match with any type parameter. Returns true if this symbols can overload another of the same kind. Returns true if this property can overload another. Helper that tells if symbol has Overloads (hidebysig) on it Member that does not have Overloads, is considered Shadows (hidebyname) Is the symbol an instance member (i.e. access requires a receiver) Is this a member of a interface that requires implementation? Returns True for "regular" properties (those that are not WithEvents. Typically used for OHI diagnostics where WithEvents properties are treated as variables. default zero-init constructor symbol is added to a struct when it does not define its own parameterless public constructor. We do not emit this constructor and do not call it Return the overridden symbol for either a method or property. Return the arity of a member. Returns the Me symbol associated with a member. sym must be a member (method, field or property) Returns the parameters of a given method or property. Is symbol a user-defined operator method. Does symbol or its containing type have Microsoft.CodeAnalysis.Embedded() attribute Does symbol or its containing type have Microsoft.VisualBasic.Embedded() attribute Gets the upper-level named type symbol, or returns Nothing if it does not exist. Try to parse the local (or parameter) name and return if successful. Try to parse the local name and return and if successful. Helper class to generate synthesized names. Generates the name of a state machine's type. Generates the name of a state machine 'state' field Generates the name of a static lambda display class instance cache Generates the name of a state machine 'builder' field Generates the name of a field that backs Current property Generates the name of a state machine's awaiter field Generates the name of a state machine's parameter name Generates the name of a state machine's parameter name Generates the name of a field where initial thread ID is stored Generates the name of a state machine field name for captured me reference Generates the name of a state machine field name for captured me reference of lambda closure Class to represent a synthesized attribute Synthesizes attribute data for given constructor symbol. If the constructor has UseSiteErrors and the attribute is optional returns Nothing. Represents a base type for compiler generated backing fields. Type parameter that represents another type parameter while being applied on a different symbol This class represents a base class for compiler generated constructors Flag to indicate if this is a shared constructor or an instance constructor. Initializes a new instance of the class. The containing type for the synthesized constructor. if set to true if this is a shared constructor. Gets the symbol name. Returns the empty string if unnamed. Gets a indicating the declared accessibility for the symbol. Returns NotApplicable if no accessibility is declared. Gets a value indicating whether this instance is abstract or not. true if this instance is abstract; otherwise, false. Gets a value indicating whether this instance is not overridable. true if this instance is not overridable; otherwise, false. Gets a value indicating whether this instance is overloads. true if this instance is overloads; otherwise, false. Gets a value indicating whether this instance is overridable. true if this instance is overridable; otherwise, false. Gets a value indicating whether this instance is overrides. true if this instance is overrides; otherwise, false. Gets a value indicating whether this instance is shared. true if this instance is shared; otherwise, false. Gets a value indicating whether this instance is sub. true if this instance is sub; otherwise, false. A potentially empty collection of locations that correspond to this instance. Gets what kind of method this is. There are several different kinds of things in the VB language that are represented as methods. This property allow distinguishing those things without having to decode the name of the method. Gets the return type of the method. This class represent a compiler generated method Initializes a new instance of the class. The parameters are not initialized and need to be set by using the method. The name of this method. The containing symbol. The flags for this method. The return type. Sets the parameters. The parameters. Note: This should be called at most once, immediately after the symbol is constructed. The parameters aren't Note: passed to the constructor because they need to have their container set correctly. Returns the arity of this method, or the number of type parameters it takes. A non-generic method has zero arity. If this method has MethodKind of MethodKind.PropertyGet or MethodKind.PropertySet, returns the property that this method is the getter or setter for. If this method has MethodKind of MethodKind.EventAdd or MethodKind.EventRemove, returns the event that this method is the adder or remover for. Calling convention of the signature. Gets the for the immediately containing symbol. Gets a indicating the declared accessibility for the symbol. Returns NotApplicable if no accessibility is declared. Returns interface methods explicitly implemented by this method. Returns true if this method is an extension method. Gets a value indicating whether this instance is external method. true if this instance is external method; otherwise, false. Gets a value indicating whether this instance is abstract or not. true if this instance is abstract; otherwise, false. Gets a value indicating whether this instance is not overridable. true if this instance is not overridable; otherwise, false. Gets a value indicating whether this instance is overloads. true if this instance is overloads; otherwise, false. Gets a value indicating whether this instance is overridable. true if this instance is overridable; otherwise, false. Gets a value indicating whether this instance is overrides. true if this instance is overrides; otherwise, false. Gets a value indicating whether this instance is shared. true if this instance is shared; otherwise, false. Gets a value indicating whether this instance is a sub. true if this instance is sub; otherwise, false. Gets a value indicating whether this instance is vararg. true if this instance is vararg; otherwise, false. A potentially empty collection of locations that correspond to this instance. Gets what kind of method this is. There are several different kinds of things in the VB language that are represented as methods. This property allow distinguishing those things without having to decode the name of the method. The parameters forming part of this signature. Gets the return type of the method. Returns the list of attributes, if any, associated with the return type. Returns the list of custom modifiers, if any, associated with the returned value. Returns the type arguments that have been substituted for the type parameters. If nothing has been substituted for a given type parameter, then the type parameter itself is consider the type argument. Get the type parameters on this method. If the method has not generic, returns an empty list. Gets a value indicating whether the symbol was generated by the compiler rather than declared explicitly. Gets the symbol name. Returns the empty string if unnamed. This class represents a synthesized delegate type derived from an Event declaration Class C Event Name(a As Integer, b As Integer) End Class defines an event and a delegate type: Event Name As NamedEventHandler Delegate Sub NameEventHandler(a As Integer, b As Integer) This property may be called while containing type is still being constructed. Therefore it can take membersInProgress context to ensure that returned symbol is relevant to the current type construction. (there could be several optimistically concurrent sessions) Force all declaration errors to be generated. This class represents a base class for compiler generated synthesized method symbols that must be emitted in the compiler generated PrivateImplementationDetails class. SynthesizedGlobalMethodBase symbols don't have a ContainingType, there are global to the containing source module and are Public Shared methods. Gets the symbol name. Returns the empty string if unnamed. Gets a value indicating whether this instance is abstract or not. true if this instance is abstract; otherwise, false. Gets a value indicating whether this instance is not overridable. true if this instance is not overridable; otherwise, false. Gets a value indicating whether this instance is overloads. true if this instance is overloads; otherwise, false. Gets a value indicating whether this instance is overridable. true if this instance is overridable; otherwise, false. Gets a value indicating whether this instance is overrides. true if this instance is overrides; otherwise, false. Gets a value indicating whether this instance is shared. true if this instance is shared; otherwise, false. A potentially empty collection of locations that correspond to this instance. Gets what kind of method this is. There are several different kinds of things in the VB language that are represented as methods. This property allow distinguishing those things without having to decode the name of the method. The parameters forming part of this signature. Exception message. Integer value of . Force all declaration errors to be generated. When signature of an implementing method differs (due to presence of custom modifiers) from the signature of implemented method, we insert a synthesized explicit interface implementation that delegates to the method declared in source. Base for synthesized Lambda methods. Just provides a bunch of defaults Creates a clone of the local with a new containing symbol and type. Note that the new parameter gets no syntaxRef as it is supposed to get all the values it needs from the original parameter. This class represents synthetic WithEvents property that overrides one in one of the base classes. When derived class contains "Handles" methods that refer to a WithEvents property in a base class, derived class needs to add a synthetic override for the base WithEvent property. We need the override so that we could inject code sequences that remove old handlers and add new handlers when something is assigned to the property. Public Class Base Protected Friend WithEvents w As Base = Me Public Event e As System.Action Sub H1() Handles w.e End Sub End Class Public Class Derived Inherits Base Sub H2() Handles w.e End Sub End Class Base (simplified) class for synthesized parameter symbols of methods that have been synthesized. E.g. the parameters of delegate methods Initializes a new instance of the class. The containing symbol The type of this parameter The ordinal number of this parameter The name of this parameter Gets the containing symbol. The list of custom modifiers, if any, associated with the parameter. Evaluate this property only if IsModified is true. A compile time constant value that should be supplied as the corresponding argument value by callers that do not explicitly specify an argument value for this parameter. True if the parameter has a default value that should be supplied as the argument value by a caller for which the argument value has not been explicitly specified. Gets a value indicating whether this instance is by ref. true if this instance is by ref; otherwise, false. True if the argument value must be included in the marshalled arguments passed to a remote callee only if it is different from the default value (if there is one). Gets a value indicating whether this instance is param array. true if this instance is param array; otherwise, false. Gets a value indicating whether the symbol was generated by the compiler rather than declared explicitly. A potentially empty collection of locations that correspond to this instance. Gets the ordinal. Gets the type. Gets the name. Base class for synthesized parameter symbols of methods that have been synthesized. E.g. the parameters of delegate methods Initializes a new instance of the class. The containing symbol The type of this parameter The ordinal number of this parameter Whether the parameter is ByRef or not The name of this parameter Initializes a new instance of the class. The containing symbol The type of this parameter The ordinal number of this parameter Whether the parameter is ByRef or not The name of this parameter Gets a value indicating whether this instance is by ref. true if this instance is by ref; otherwise, false. True if the argument value must be included in the marshalled arguments passed to a remote callee only if it is different from the default value (if there is one). A compile time constant value that should be supplied as the corresponding argument value by callers that do not explicitly specify an argument value for this parameter. True if the parameter has a default value that should be supplied as the argument value by a caller for which the argument value has not been explicitly specified. Initializes a new instance of the class. The containing symbol The type of this parameter The ordinal number of this parameter Whether the parameter is ByRef or not The name of this parameter The custom modifiers of this parameter type The custom modifiers of ref modifier The list of custom modifiers, if any, associated with the parameter. Evaluate this property only if IsModified is true. Extends SynthesizedParameterSymbol to also accept a location A base class for symbols representing a synthesized property. This class represents a base class for compiler generated methods Gets the symbol name. Returns the empty string if unnamed. Gets a value indicating whether this instance is abstract or not. true if this instance is abstract; otherwise, false. Gets a value indicating whether this instance is not overridable. true if this instance is not overridable; otherwise, false. Gets a value indicating whether this instance is overloads. true if this instance is overloads; otherwise, false. Gets a value indicating whether this instance is overridable. true if this instance is overridable; otherwise, false. Gets a value indicating whether this instance is overrides. true if this instance is overrides; otherwise, false. Gets a value indicating whether this instance is shared. true if this instance is shared; otherwise, false. A potentially empty collection of locations that correspond to this instance. Gets what kind of method this is. There are several different kinds of things in the VB language that are represented as methods. This property allow distinguishing those things without having to decode the name of the method. The parameters forming part of this signature. This class represents a simple implementation of compiler generated constructors Sets the parameters. The parameters. This class represents a base class for compiler generated methods Sets the parameters. The parameters. Represents a field of a tuple type (such as (int, byte).Item1) that doesn't have a corresponding backing field within the tuple underlying type. Created in response to an error condition. If this field represents a tuple element with index X, the field contains 2X if this field represents a Default-named element 2X + 1 if this field represents a Friendly-named element Otherwise, (-1 - [index in members array]); If this is a field representing a tuple element, returns the index of the element (zero-based). Otherwise returns -1 Represents an event of a tuple type (such as (int, byte).SomeEvent) that is backed by an event within the tuple underlying type. Represents a non-element field of a tuple type (such as (int, byte).Rest) that is backed by a real field within the tuple underlying type. If this field represents a tuple element with index X, the field contains 2X if this field represents a Default-named element 2X + 1 if this field represents a Friendly-named element Otherwise, (-1 - [index in members array]); If this is a field representing a tuple element, returns the index of the element (zero-based). Otherwise returns -1 Represents an element field of a tuple type (such as (int, byte).Item1) that is backed by a real field with the same name within the tuple underlying type. Represents an element field of a tuple type (such as (int a, byte b).a, or (int a, byte b).b) that is backed by a real field with a different name within the tuple underlying type. Represents a method of a tuple type (such as (int, byte).ToString()) that is backed by a method within the tuple underlying type. Represents a parameter of a method or a property of a tuple type Represents a property of a tuple type (such as (int, byte).SomeProperty) that is backed by a property within the tuple underlying type. Names of the elements as provided when tuple was created Which element names were inferred and therefore cannot be used. If none of the element names were inferred, or inferred names can be used (no tracking necessary), leave as default. This information is ignored in type equality and comparison. Actual element names. Could be different from _providedElementNames because of case insensitivity. I.E. - it is not an error to provide "item1" name to the first element however its name must be "Item1", since it already has the name "Item1" and having both "item1" and "Item1" names would be ambiguous Get the default fields for the tuple's elements (in order and cached). A type parameter constraint: a single 'New', 'Class', 'Structure' constraint or a specific type constraint. Immutable. Thread-safe. Represents a type substitution, with substitutions of types for a set of type parameters. Each TypeSubstitution object has three pieces of information: - OriginalDefinition of generic symbol the substitution is targeting. - An array of pairs that provide a mapping from symbol's type parameters to type arguments. identity substitutions are omitted. - TypeSubstitution object for containing type to provide mapping for its type parameters, if any. The identity substitution (for the whole type hierarchy) is represented by Nothing. That said, top level parent of non-Nothing instance of TypeSubstitution is guaranteed to be non-identity substitution. The instance may still be an identity substitution just for target generic definition, which will be represented by an empty mapping array. The chain of TypeSubstitution objects is guaranteed to not skip any type in the containership hierarchy, even types with zero arity contained in generic type will have corresponding TypeSubstitution object with empty mapping array. Example: Class A(Of T,S) Class B Class C(Of U) End Class End Class End Class TypeSubstitution for A(Of Integer, S).B.C(Of Byte) is C{U->Byte}=>B{}=>A{T->Integer} TypeSubstitution for A(Of T, S).B.C(Of Byte) is C{U->Byte} TypeSubstitution for A(Of Integer, S).B is B{}=>A{T->Integer} TypeSubstitution for A(Of Integer, S).B.C(Of U) is C{}=>B{}=>A{T->Integer} CONSIDER: An array of KeyValuePair(Of TypeParameterSymbol, TypeSymbol)objects is used to represent type parameter substitution mostly due to historical reasons. It might be more convenient and more efficient to use ordinal based array of TypeSymbol objects instead. There is a Construct method that can be called on original definition with TypeSubstitution object as an argument. The advantage of that method is the ability to substitute type parameters of several types in the containership hierarchy in one call. What type the TypeSubstitution parameter targets makes a difference. For example: C.Construct(C{}=>B{}=>A{T->Integer}) == A(Of Integer, S).B.C(Of U) C.Construct(B{}=>A{T->Integer}) == A(Of Integer, S).B.C(Of ) B.Construct(B{}=>A{T->Integer}) == A(Of Integer, S).B See comment for IsValidToApplyTo method as well. A map between type parameters of _targetGenericDefinition and corresponding type arguments. Represented by an array of Key-Value pairs. Keys are type parameters of _targetGenericDefinition in no particular order. Identity substitutions are omitted. Definition of a symbol which this instance of TypeSubstitution primarily targets. An instance of TypeSubstitution describing substitution for containing type. Get all the pairs of substitutions, including from the parent substitutions. The substitutions are in order from outside-in (parent substitutions before child substitutions). Verify TypeSubstitution to make sure it doesn't map any type parameter to an alpha-renamed type parameter. Return TypeSubstitution instance that targets particular generic definition. Return TypeSubstitution instance that targets particular generic definition or one of its containers. Does substitution target either genericDefinition or one of its containers? Combine two substitutions into one by concatenating. They may not directly or indirectly (through Parent) target the same generic definition. sub2 is expected to target types lower in the containership hierarchy. Either or both can be Nothing. targetGenericDefinition specifies target generic definition for the result. If sub2 is not Nothing, it must target targetGenericDefinition. If sub2 is Nothing, sub1 will be "extended" with identity substitutions to target targetGenericDefinition. Create a substitution. If the substitution is the identity substitution, Nothing is returned. Generic definition the result should target. Type parameter definitions. Duplicates aren't allowed. Type parameters of containing type must precede type parameters of a nested type. Corresponding type arguments. Create a substitution. If the substitution is the identity substitution, Nothing is returned. Generic definition the result should target. Type parameter definitions. Duplicates aren't allowed. Type parameters of containing type must precede type parameters of a nested type. Corresponding type arguments. Private helper to make sure identity substitutions are injected for types between targetGenericDefinition and parent.TargetGenericDefinition. Create substitution to handle alpha-renaming of type parameters. It maps type parameter definition to corresponding alpha-renamed type parameter. Alpha-renamed type parameters. Create TypeSubstitution that can be used to substitute method's type parameters in types involved in method's signature. Unlike for other construction methods in this class, targetMethod doesn't have to be original definition, it is allowed to be specialized unconstructed generic method. An item in typeArguments can be an alpha-renamed type parameter, but it must belong to the targetMethod and can only appear at its ordinal position to represent the lack of substitution for it. Adjust substitution for construction. This has the following effects: 1) The passed in additionalSubstitution is used on each type argument. 2) If any parameters in the given additionalSubstitution are not present in oldConstructSubstitution, they are added. 3) Parent substitution in oldConstructSubstitution is replaced with adjustedParent. oldConstructSubstitution can be cancelled out by additionalSubstitution. In this case, if the adjustedParent is Nothing, Nothing is returned. This has the following effects: 1) The passed in additionalSubstitution is used on each type argument. 2) If any parameters in the given additionalSubstitution are not present in oldConstructSubstitution, they are added. Result is placed into pairs. Identity substitutions are omitted. Returns True if the set of pairs have changed, False otherwise. Create substitution for targetGenericDefinition based on its type arguments (matched to type parameters by position) and TypeSubstitution for direct or indirect container. A TypeSymbol is a base class for all the symbols that represent a type in Visual Basic. Map with all the explicitly implemented interface symbols declared on this type. key = interface method/property/event compared using , value = explicitly implementing methods/properties/events declared on this type (normally a single value, multiple in case of an error). Access through property ONLY! Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Gets the BaseType of this type. If the base type could not be determined, then an instance of ErrorType is returned. If this kind of type does not have a base type (for example, interfaces), Nothing is returned. Also the special class System.Object always has a BaseType of Nothing. Gets the set of interfaces that this type directly implements. This set does not include interfaces that are base interfaces of directly implemented interfaces. The list of all interfaces of which this type is a declared subtype, excluding this type itself. This includes all declared base interfaces, all declared base interfaces of base types, and all declared base interfaces of those results (recursively). Each result appears exactly once in the list. This list is topologically sorted by the inheritance relationship: if interface type A extends interface type B, then A precedes B in the list. This is not quite the same as "all interfaces of which this type is a proper subtype" because it does not take into account variance: AllInterfaces for IEnumerable(Of String) will not include IEnumerable(Of Object). Produce all implemented interfaces in topologically sorted order. We use TypeSymbol.Interfaces as the source of edge data, which has had cycles and infinitely long dependency cycles removed. Consequently, it is possible (and we do) use the simplest version of Tarjan's topological sorting algorithm. Gets the set of interfaces that this type directly implements, plus the base interfaces of all such types. Keys are compared using , values are distinct interfaces corresponding to the key, according to rules. CONSIDER: it probably isn't truly necessary to cache this. If space gets tight, consider alternative approaches (recompute every time, cache on the side, only store on some types, etc). Returns true if this type is known to be a reference type. It is never the case that and both return true. However, for an unconstrained type parameter, and will both return false. Returns true if this type is known to be a value type. It is never the case that and both return true. However, for an unconstrained type parameter, and will both return false. Is this a symbol for an anonymous type (including delegate). Gets the kind of this type. Gets corresponding special TypeId of this type. Gets corresponding primitive type code for this type declaration. Substitute the given type substitution within this type, returning a new type. If the substitution had no effect, return Me. !!! Only code implementing construction of generic types is allowed to call this method !!! !!! All other code should use Construct methods. !!! Lookup an immediately nested type referenced from metadata, names should be compared case-sensitively. Type name. Symbol for the type, or Nothing if the type isn't found. Verify if the given type can be used to back a tuple type and return cardinality of that tuple type in . If method returns true, contains cardinality of the compatible tuple type. Verify if the given type can be used to back a tuple type. Verify if the given type is a tuple of a given cardinality, or can be used to back a tuple type with the given cardinality. Return error code that has highest priority while calculating use site error for this symbol. Returns the corresponding symbol in this type or a base type that implements interfaceMember (either implicitly or explicitly), or null if no such symbol exists (which might be either because this type doesn't implement the container of interfaceMember, or this type doesn't supply a member that successfully implements interfaceMember). Must be a non-null interface property, method, or event. The implementing member. Compute the implementation for an interface member in this type, or Nothing if none. Get a dictionary with all the explicitly implemented interface symbols declared on this type. key = interface method/property/event compared using , value = explicitly implementing methods/properties/events declared on this type (normally a single value, multiple in case of an error). Note: This implementation is overridden by source symbols, because they diagnose errors also. Compares types ignoring some differences. Return true if nothing can inherit or implement this type. Dig through possibly jagged array type to the ultimate element type Returns true if is/inherits from/implements IEnumerable(Of U), and U is/inherits from/implements The type to check compatibility for. The type argument for IEnumerable(Of ...) True if type can be assigned to a IEnumerable(Of typeArgument); otherwise False. This is not a general purpose helper. Determines whether the given type is valid for a const field. VB Spec 9.5: The type of a constant may only be a primitive type or Object The type of the field. true if type is valid for a const field; otherwise, false. Return true if the type contains any tuples. Return true if the type contains any tuples with element names. Visit the given type and, in the case of compound types, visit all "sub type" (such as A in A(), or { A(Of T), T, U } in A(Of T).B(Of U)) invoking 'predicate' with the type and 'arg' at each sub type. If the predicate returns true for any type, traversal stops and that type is returned from this method. Otherwise if traversal completes without the predicate returning true for any type, this method returns null. Determines if the type is a valid type for a custom attribute argument The only valid types are 1. primitive types except date and decimal, 2. object, system.type, public enumerated types 3. one dimensional arrays of (1) and (2) above Add this instance to the set of checked types. Returns True if this type was added, False if the type was already in the set. Checks for validity of type arguments passed to Construct(...) method Returns Nothing for identity substitution. Returns Nothing for identity substitution. Is this type System.Linq.Expressions.Expression(Of T) for some delegate type T. If so, return the type argument, else return nothing. The passed-in compilation is used to find the well-known-type System.Linq.Expressions.Expression(Of T). If the passed in type is a delegate type D, return D. If the passed in type is a System.Linq.Expressions.Expression(Of D) for a delegate type D, return D. Else return Nothing If the passed in type is a delegate type D, return D and set wasExpression to False If the passed in type is a System.Linq.Expressions.Expression(Of D) for a delegate type D, return D and set wasExpression to True Else return Nothing and set wasExpression to False If the passed in type is a System.Linq.Expressions.Expression(Of D) for a delegate type D, return True Return all of the type parameters in this type and enclosing types, from outer-most to inner-most type. Return all of the type parameters in this type and enclosing types, from outer-most to inner-most type. Return all of the type arguments in this type and enclosing types, from outer-most to inner-most type. Return all of the type arguments and their modifiers in this type and enclosing types, from outer-most to inner-most type. Return true if the fully qualified name of the type's containing symbol matches the given name. This method avoids string concatenations in the common case where the type is a top-level type. Extract type under assumption that there should be no custom modifiers. The method asserts otherwise. Given a possibly constructed/specialized generic type, create a symbol to represent an unbound generic type for its definition. Force all declaration errors to be generated. Represents an event that is based on another event. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Represents a field that is based on another field. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Represents a method that is based on another method. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Represents a named type that is based on another named type. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Represents a parameter that is based on another parameter. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Represents a property that is based on another property. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Represents a type parameter that is based on another type parameter. When inheriting from this class, one shouldn't assume that the default behavior it has is appropriate for every case. That behavior should be carefully reviewed and derived type should override behavior as appropriate. Provides context for binding top-level statements in a script. Create binder for binding the body of a method. Provides lookup in types of imported namespaces, either at file level or project level. Collect extension methods with the given name that are in scope in this binder. The passed in ArrayBuilder must be empty. Extension methods from the same containing type must be grouped together. Binder used to bind using blocks. It hosts the variables declared in the resource list (if they are declared). Holds all information needed to rewrite a bound using block node. A dictionary holding a placeholder, a conversion from placeholder to IDisposable and a condition if placeholder IsNot nothing per type. Syntax node for the using block. Initializes a new instance of the class. The syntax node for the using block A dictionary holding a placeholder, a conversion from placeholder to IDisposable and a condition if placeholder IsNot nothing per type. Gets the Binder.DelegateResolutionResult for the given targetType. One needs to call GetConversionClassification before in order to fill the cache. Type of the target. The Binder.DelegateResolutionResult for the conversion of the AddressOf operand to the target type Gets the conversion classification. The destination type to convert to. Gets a value indicating whether this do loop is a DoTopLoop or not. In syntax error cases where both conditions are used, priority is given to the first one. It's recommended to consistently use this property instead of checking the TopConditionOpt and BottomConditionOpt directly. true if this loop is a DoTopLoop; otherwise, false. Gets a value indicating whether the condition of this do loop is "until" or not. In syntax error cases where both conditions are used, priority is given to the first one. It's recommended to consistently use this property instead of checking TopConditionIsUntil and BottomConditionIsUntil directly. true if this loop is a DoTopLoop; otherwise, false. Gets the optional bound condition expression for this do loop statement. In syntax error cases where both conditions are used, priority is given to the first one. It's recommended to consistently use this property instead of accessing TopConditionOpt or BottomConditionOpt directly. Returns true if calls and delegate invocations with this expression as the receiver should be non-virtual calls. Does expression refer to a physical memory location that can be modified? Note, Dev10 uses SXF_LVALUE flag on bound nodes to represent this concept. Returns True if the node specified is one of Me/MyClass/MyBase Returns True if the expression is a property access expression, either directly or wrapped in an XML member access expression. Does this node represent a property with Set accessor and AccessKind not yet bound to Get? Does this node represent a property or latebound access not yet determined to be Get? Get the access kind from property access expression. Sets the access kind on the property access expression. To clear the access kind, 'newAccessKind' should be Unknown. Otherwise, the current property access kind should be Unknown or equal to 'newAccessKind'. Return a BoundXmlMemberAccess node with updated MemberAccess property. Return true if and only if an expression is a integral literal with a value of zero. Non-literal constant value zero does not qualify. Return true if and only if an expression is a integral literal with a value of zero. Non-literal constant value zero does not qualify. Checks if the expression is a default value (0 or Nothing) Checks if the expression is a constant and that constant is False Checks if the expression is a constant and that constant is True Checks if the expression is a negative integer constant value. Return the integer constant value (if any) from a BoundExpression Return true if and only if an expression is a semantical Nothing literal, which is defined as follows (the definition is consistent with definition used by Dev10 compiler): - A Nothing literal according to the language grammar, or - A parenthesized expression, for which IsNothingLiteral returns true, or - An expression of type Object with constant value == Nothing. Return true if target BoundLiteral represents Nothing literal as defined by the language grammar. Return true if and only if an expression represents optionally parenthesized Nothing literal as defined by the language grammar. I.e. implicit conversions are Ok, but explicit conversions aren't. returns type arguments or Nothing if group does not have type arguments. Should this lambda be treated as a single line lambda? Updates access kind. To clear the access kind, 'newAccessKind' should be Unknown. Otherwise, the current access kind should be Unknown or equal to 'newAccessKind'. Updates property access kind. To clear the access kind, 'newAccessKind' should be Unknown. Otherwise, the current access kind should be Unknown or equal to 'newAccessKind'. returns name used to lookup the method/property in the group. returns the container of the first member in the group. The node should not be treated as a direct semantical representation of the syntax it is associated with. Some examples: - implicit call for base constructor is associated with the constructor syntax. - code in compiler generated constructor is associated with the type declaration. Nodes marked this way are likely to be skipped by SemanticModel, Sequence Point rewriter, etc. Override this property to return the child nodes if the IOperation API corresponding to this bound node is not yet designed or implemented. Note that any of the child bound nodes may be null. Get the Binder from a lambda node, or return Nothing if this isn't a lambda node. The visitor which searches for a bound node inside a bound subtree Note: Nothing if node is found Updates property access kind. To clear the access kind, 'newAccessKind' should be Unknown. Otherwise, the current access kind should be Unknown or equal to 'newAccessKind'. If the access includes a set, the type of the expression is the type of the setter value parameter. Otherwise, the type of the expression is the return type of the getter. Consumers must provide implementation for . We should be intentional about behavior of derived classes regarding guarding against stack overflow. Returns the placeholder used in this With statement to substitute the expression in initial binding A draft version of initializers which will be used in this With statement. Initializers are expressions which are used to capture expression in the current With statement; they can be empty in some cases like if the expression is a local variable of value type. Note, the initializers returned by this property are 'draft' because they are generated based on initial bound tree, the real initializers will be generated in lowering based on lowered expression form. A draft version of placeholder substitute which will be used in this With statement. Note, the placeholder substitute returned by this property is 'draft' because it is generated based on initial bound tree, the real substitute will be generated in lowering based on lowered expression form. Suppresses RValue validation when constructing the node. Must be used _only_ when performing lambda inference where RValue inconsistency on this node is intentionally allowed. If such node makes into a regular bound tree it will be eventually rewritten (all Yields are rewritten at some point) and that will trigger validation. For nodes that can generate an , this allows the Lazy implementation to get the children of this node on demand. NoOpStatementFlavor specifies additional info that NoOp statement may be carrying; Such info may be used in rewriting or code gen phases to perform some special actions Marks a control yield point for emitted await operator; is processed by codegen; only allowed inside MoveNext methods generated for Async methods Marks a control resume point for emitted await operator; is processed by codegen; only allowed inside MoveNext methods generated for Async methods BoundExpressions to be used for emit. The expressions are assumed to be lowered and will not be visited by . Should this lambda be treated as a single line lambda? Is this a function lambda target.ReturnType is ignored and must be Void, only parameter types are taken into consideration. This class is used to cache various information about a lambda in the course of binding an expression/statement containing the lambda. Even though the members are public, they shouldn't be accessed directly by any code outside of the UnboundLambda class. Keeps track on current nesting level of try statements Current enclosing Catch block if there is any. Emits address as in & May introduce a temp which it will return. (otherwise returns null) Emits address of a temp. Used in cases where taking address directly is not possible (typically because expression does not have a home) Will introduce a temp which it will return. Checks if expression represents directly or indirectly a value with its own home. In such cases it is possible to get a reference without loading into a temporary. This is a CLR concept which is weaker than VB's IsLValue. For example all locals are homed even if VB may consider some locals read-only. Special HasHome for fields. Fields have homes when they are writable. Checks if it is allowed to take a writable reference to expression according to VB rules. Checks if it is allowed to take a writable reference to expression according to VB rules. Can take a reference. Emits receiver in a form that allows member accesses ( O or & ). For verifiably reference types it is the actual reference. For generic types it is a address of the receiver with readonly intent. For the value types it is an address of the receiver. isAccessConstrained indicates that receiver is a target of a constrained callvirt in such case it is unnecessary to box a receiver that is typed to a type parameter May introduce a temp which it will return. (otherwise returns null) May introduce a temp which it will return. (otherwise returns null) Entry point to the array initialization. Assumes that we have newly created array on the stack. inits could be an array of values for a single dimensional array or an array (of array)+ of values for a multidimensional case in either case it is expected that number of leaf values will match number of elements in the array and nesting level should match the rank of the array. To handle array initialization of arbitrary rank it is convenient to approach multidimensional initialization as a recursively nested. ForAll{i, j, k} Init(i, j, k) ===> ForAll{i} ForAll{j, k} Init(i, j, k) ===> ForAll{i} ForAll{j} ForAll{k} Init(i, j, k) This structure is used for capturing initializers of a given index and the index value itself. Emits all initializers that match indices on the stack recursively. Example: if array has [0..2, 0..3, 0..2] shape and we have {1, 2} indices on the stack initializers for [1, 2, 0] [1, 2, 1] [1, 2, 2] will be emitted and the top index will be pushed off the stack as at that point we would be completely done with emitting initializers corresponding to that index. Count of all initializers. Produces a serialized blob of all constant initializers. Non-constant initializers are matched with a zero of corresponding size. Check if it is a regular collection of expressions or there are nested initializers. Returns parameterless value type constructor. Used to decide if we need to emit call or callvirt. It basically checks if the receiver expression cannot be null, but it is not 100% precise. There are cases where it really can be null, but we do not care. checks if receiver is effectively ldarg.0 Used to decide if we need to emit 'call' or 'callvirt' for structure method. It basically checks if the method overrides any other and method's defining type is not a 'special' or 'special-by-ref' type. Emit code for a ternary conditional operator. if (b, x, y) becomes push b if pop then goto CONSEQUENCE push y goto DONE CONSEQUENCE: push x DONE: Emit code for a null-coalescing operator. if(x, y) becomes push x dup x if pop isnot null goto LEFT_NOT_NULL pop push y LEFT_NOT_NULL: Emit an element store instruction for a single dimensional array. Emits boolean expression without branching if possible (i.e., no logical operators, only comparisons). Leaves a boolean (int32, 0 or 1) value on the stack which conforms to sense, i.e., condition = sense. Tells if we should emit [Set/Clear]ProjectErrors when entering/leaving handlers tells if given node contains a label statement that defines given label symbol Delegate to emit string compare call and conditional branch based on the compare result. Key to compare Node for diagnostics Case constant to compare the key against Target label to branch to if key = stringConstant String equality method Gets the name And id of the local that are going to be generated into the debug metadata. Gets already declared and initialized local. Allocates a temp without identity. Frees a temp without identity. Frees an optional temp. Optimizer performs optimization of the bound tree performed before passing it to a codegen. Generally it may include several phases like stack scheduling of local variables, etc... context of expression evaluation. it will affect inference of stack behavior it will also affect when expressions can be dup-reused Example: Goo(x, ref x) x cannot be duped as it is used in different context Analyzes the tree trying to figure which locals may live on stack. It is a fairly delicate process and must be very familiar with how CodeGen works. It is essentially a part of CodeGen. NOTE: It is always safe to mark a local as not eligible as a stack local so when situation gets complicated we just refuse to schedule and move on. fake local that represents the eval stack. when we need to ensure that eval stack is not blocked by stack Locals, we record an access to empty. here we have a case of indirect assignment: *t1 = expr; normally we would need to push t1 and that will cause spilling of t2 TODO: an interesting case arises in unused x[i]++ and ++x[i] : we have trees that look like: t1 = &(x[0]) t2 = *t1 *t1 = t2 + 1 t1 = &(x[0]) t2 = *t1 + 1 *t1 = t2 in these cases, we could keep t2 on stack (dev10 does). we are dealing with exactly 2 locals and access them in strict order t1, t2, t1, t2 and we are not using t2 after that. We may consider detecting exactly these cases and pretend that we do not need to push either t1 or t2 in this case. VB uses a special node to assign references. BoundAssignment is used only to assign values. therefore an indirect assignment may only happen if lhs is a reference Ensures that there are no stack locals. It is done by accessing virtual "empty" local that is at the bottom of all stack locals. Represents a local and its Def-Use-Use chain NOTE: stack local reads are destructive to the locals so if the read is not last one, it must be immediately followed by another definition. For the rewriting purposes it is irrelevant if definition was created by a write or a subsequent read. These cases are not ambiguous because when rewriting, definition will match to a single node and we always know if given node is reading or writing. stack at variable declaration, may be > 0 in sequences. value definitions for this variable once this goes to true we are no longer interested in this variable. Represents a span of a value between definition and use. Start/end positions are specified in terms of global node count as visited by StackOptimizer visitors. (i.e. recursive walk not looking into constants) when current And other use spans are regular spans we can have only 2 conflict cases: [1, 3) conflicts with [0, 2) [1, 3) conflicts with [2, 4) NOTE: With regular spans, it is not possible for two spans to share an edge point unless they belong to the same local. (because we cannot access two real locals at the same time) specifically: [1, 3) does Not conflict with [0, 1) since such spans would need to belong to the same local Dummy locals represent implicit control flow it is not allowed for a regular local span to cross into or be immediately adjacent to a dummy span. specifically: [1, 3) does conflict with [0, 1) since that would imply a value flowing into or out of a span surrounded by a branch/label Rewrites the tree to account for destructive nature of stack local reads. Typically, last read stays as-is and local is destroyed by the read. Intermediate reads are rewritten as Dups - NotLastUse(X_stackLocal) ===> NotLastUse(Dup) LastUse(X_stackLocal) ===> LastUse(X_stackLocal) Built-in binary operators bound in "OperandOfConditionalBranch" mode are marked with this flag by the Binder, which makes them eligible for some optimizations in marks built-in binary operators with this flag in order to inform that the operator should be a subject for optimization around use of three-valued Boolean logic. The optimization should be applied only when we are absolutely sure that we will "snap" Null to false. That is when we actually have the as the ancestor and no user defined operators in between. We simply don't know that information during binding because we haven't bound binary operators up the hierarchy yet. So the optimization is triggered by the fact of snapping Null to false (getting to the method) and then we are making sure we don't have anything unexpected in between. Allocates resumable states, i.e. states that resume execution of the state machine after await expression or yield return. The number of the next generated resumable state (i.e. state that resumes execution of the state machine after await expression or yield return). EnC support: number of states in this state machine that match states of the previous generation state machine. True if any of the states generated for any previous state machine has not been allocated in this version. The CommandLineArguments class provides members to Set and Get Visual Basic compilation and parse options. Set and Get the Visual Basic compilation options. The currently set Visual Basic compilation options. Set and Get the Visual Basic parse options. The currently set Visual Basic parse options. Gets the core Parse options. The currently set core parse options. Gets the core compilation options. The currently set core compilation options. The VisualBasicCommandLineParser class contains members used to perform various Visual Basic command line parsing operations. Gets the current command line parser. Gets the current interactive command line parser. Creates a new command line parser. An optional parameter indicating whether to create a interactive command line parser. Gets the standard Visual Basic source file extension A string representing the standard Visual Basic source file extension. Gets the standard Visual Basic script file extension. A string representing the standard Visual Basic script file extension. Parses a command line. A collection of strings representing the command line arguments. The base directory used for qualifying file locations. The directory to search for mscorlib, or Nothing if not available. A string representing additional reference paths. A CommandLineArguments object representing the parsed command line. Converts a sequence of definitions provided by a caller (public API) into map of definitions used internally. Invalid value provided. Converts ImmutableDictionary of definitions used internally into IReadOnlyDictionary of definitions returned to a caller (of public API) Parses Conditional Compilations Symbols. Given the string of conditional compilation symbols from the project system, parse them and merge them with an IReadOnlyDictionary ready to be given to the compilation. The conditional compilation string. This takes the form of a comma delimited list of NAME=Value pairs, where Value may be a quoted string or integer. A collection of reported diagnostics during parsing of symbolList, can be empty IEnumerable. A collection representing existing symbols. Symbols parsed from will be merged with this dictionary. Invalid value provided. NOTE: implicit line continuation will not be handled here and an error will be generated, but explicit one (like ".... _\r\n ....") should work fine Parses the given platform option. Legal strings are "anycpu", "x64", "x86", "itanium", "anycpu32bitpreferred", "arm". In case an invalid value was passed, anycpu is returned. The value for platform. The error bag. Parses the file alignment option. In case an invalid value was passed, nothing is returned. The name of the option. The value for the option. The error bag. Parses the base address option. In case an invalid value was passed, nothing is returned. The name of the option. The value for the option. The error bag. Parses the warning option. The value for the option. In VB, if the output file name isn't specified explicitly, then it is derived from the name of the first input file. http://msdn.microsoft.com/en-us/library/std9609e(v=vs.110) Specify the full name and extension of the file to create. If you do not, the .exe file takes its name from the source-code file containing the Sub Main procedure, and the .dll file takes its name from the first source-code file. However, vbc.cpp has: Print compiler logo Print Commandline help message (up to 80 English characters per line) Structure containing all semantic information about an Await expression. Initializes a new instance of the structure. Gets the "GetAwaiter" method. Gets the "GetResult" method. Gets the "IsCompleted" property. This structure holds the relevant bound node information relating to a particular syntax node, used temporarily for GetSemanticInfo and similar APIs. Traverses the symbol table checking for CLS compliance. Gets a value indicating whether Is allowed to analyze in parallel. Traverses the symbol table checking for CLS compliance. Compilation that owns the symbol table. Will be supplemented with documentation comment diagnostics. To stop traversing the symbol table early. Only report diagnostics from this syntax tree, if non-null. If and is non-null, report diagnostics within this span in the . NOTE: Dev11 does some pretty weird things here. First, it ignores arity, which seems like a good way to disambiguate symbols (in particular, CLS Rule 43 says that the name includes backtick-arity). Second, it does not consider two members with identical names (i.e. not differing in case) to collide. What is the argument to the (first) CLSCompliantAttribute on this symbol, if there is one? Consider attributes inherited from base types. What is the argument to the (first) CLSCompliantAttribute on this symbol, if there is one? Do not consider attributes inherited from base types. Return the containing module if the output kind is module and the containing assembly otherwise. Based on CompilationPass::CLSReduceSignature. The Compilation object is an immutable representation of a single invocation of the compiler. Although immutable, a Compilation is also on-demand, in that a compilation can be created quickly, but will that compiler parts or all of the code in order to respond to method or properties. Also, a compilation can produce a new compilation with a small change from the current compilation. This is, in many cases, more efficient than creating a new compilation from scratch, as the new compilation can share information from the old compilation. For semantic model scenarios we continue processing documentation comment even in presence of some errors. Now, we detect semantic model context from '_isForSingleSymbol' flag, later we might consider introducing an explicit flag Given a DocumentationCommentTriviaSyntax and the symbol, return the full documentation comment text. Gets the value of the first 'name' attribute on the element, returns Nothing in case the attribute was not found or has an invalid value, reports necessary diagnostics in the latest case Return symbol text name the way Dev11 does it Rewrites nodes in , which Is a snapshot of nodes from the original document. We're mutating the tree as we rewrite, so it's important to grab a snapshot of the nodes that we're going to reparent before we enumerate them. True, if the comment was written Generates the documentation comment for the type, writes it into the writer Given the full text of a documentation comment, strip off the comment punctuation (''') and add appropriate indentations. Find the first non-whitespace character in a given substring. The string to search The start index The last index (non-inclusive) The index of the first non-whitespace char after index start in the string up to, but not including the end index Given a string which may contain newline sequences, get the index of the first newline sequence beginning at the given starting index. The string to split. The starting index within the string. The length of the newline sequence discovered. 0 if the end of the string was reached, otherwise either 1 or 2 chars The index of the start of the first newline sequence following the start index Given the full text of a single-line style documentation comment, for each line, strip off the comment punctuation (''') and flatten the text. WORKAROUND: We're taking a dependency on the location and structure of a framework assembly resource. This is not a robust solution. Possible alternatives: 1) Polish our XML parser until it matches MSXML. We don't want to reinvent the wheel. 2) Build a map that lets us go from XML string positions back to source positions. This is what the native compiler did, and it was a lot of work. We'd also still need to modify the message. 3) Do not report a diagnostic. This is very unhelpful. 4) Report a vague diagnostic (i.e. there's a problem somewhere in this doc comment). This is relatively unhelpful. 5) Always report the message in English, so that we can pull it apart without needing to mess with resource files. This engenders a lot of ill will. 6) Report the exception message without modification and (optionally) include the text with respect to which the position is specified. This looks amateurish. Traverses the symbol table processing XML documentation comments and optionally writing them to a provided stream. Compilation that owns the symbol table. Assembly name override, if specified. Otherwise the of the source assembly is used. Stream to which XML will be written, if specified. Will be supplemented with documentation comment diagnostics. To stop traversing the symbol table early. Only report diagnostics from this syntax tree, if non-null. If and filterSpanWithinTree is non-null, report diagnostics within this span in the . Gets the XML that would be written to the documentation comment file for this assembly. The symbol for which to retrieve documentation comments. True to treat includes as semantically meaningful (pull in contents from other files and bind crefs, etc). To stop traversing the symbol table early. Walks a DocumentationCommentTriviaSyntax, binding the semantically meaningful parts to produce diagnostics and to replace source crefs with documentation comment IDs. Given a DocumentationCommentTriviaSyntax, return the full text, but with documentation comment IDs substituted into crefs. most of time all compilation would use same MyTemplate. no reason to create (reparse) one for each compilation as long as its parse option is same The SourceAssemblySymbol for this compilation. Do not access directly, use Assembly property instead. This field is lazily initialized by ReferenceManager, ReferenceManager.CacheLockObject must be locked while ReferenceManager "calculates" the value and assigns it, several threads must not perform duplicate "calculation" simultaneously. Holds onto data related to reference binding. The manager is shared among multiple compilations that we expect to have the same result of reference binding. In most cases this can be determined without performing the binding. If the compilation however contains a circular metadata reference (a metadata reference that refers back to the compilation) we need to avoid sharing of the binding results. We do so by creating a new reference manager for such compilation. The options passed to the constructor of the Compilation The global namespace symbol. Lazily populated on first access. The syntax trees explicitly given to the compilation at creation, in ordinal order. The syntax trees of this compilation plus all 'hidden' trees added to the compilation by compiler, e.g. Vb Core Runtime. A map between syntax trees and the root declarations in the declaration table. Incrementally updated between compilation versions when source changes are made. Imports appearing in s in this compilation. Unlike in C#, we don't need to use a set because the objects that record the imports are persisted. Cache the CLS diagnostics for the whole compilation so they aren't computed repeatedly. NOTE: Presently, we do not cache the per-tree diagnostics. A SyntaxTree and the associated RootSingleNamespaceDeclaration for an embedded syntax tree in the Compilation. Unlike the entries in m_rootNamespaces, the SyntaxTree here is lazy since the tree cannot be evaluated until the references have been resolved (as part of binding the source module), and at that point, the SyntaxTree may be Nothing if the embedded tree is not needed for the Compilation. The declaration table that holds onto declarations from source. Incrementally updated between compilation versions when source changes are made. Manages anonymous types declared in this compilation. Unifies types that are structurally equivalent. Manages automatically embedded content. MyTemplate automatically embedded from resource in the compiler. It doesn't feel like it should be managed by EmbeddedSymbolManager because MyTemplate is treated as user code, i.e. can be extended via partial declarations, doesn't require "on-demand" metadata generation, etc. SyntaxTree.Dummy means uninitialized. Contains the main method of this assembly, if there is one. The set of trees for which a has been added to the queue. The common language version among the trees of the compilation. The language version that was used to parse the syntax trees of this compilation. SyntaxTree of MyTemplate for the compilation. Settable for testing purposes only. Create a new compilation from scratch. Simple assembly name. The syntax trees with the source code for the new compilation. The references for the new compilation. The compiler options to use. A new compilation. Creates a new compilation that can be used in scripting. Create a duplicate of this compilation with different symbol instances Creates a new compilation with the specified name. Creates a new compilation with the specified references. The new will query the given for the underlying metadata as soon as the are needed. The New compilation uses whatever metadata is currently being provided by the . E.g. if the current compilation references a metadata file that has changed since the creation of the compilation the New compilation is going to use the updated version, while the current compilation will be using the previous (it doesn't change). Returns a new compilation with the given compilation set as the previous submission. Returns a new compilation with the given semantic model provider. Returns a new compilation with a given event queue. Get a read-only list of the syntax trees that this compilation was created with. Get a read-only list of the syntax trees that this compilation was created with PLUS the trees that were automatically added to it, i.e. Vb Core Runtime tree. Is the passed in syntax tree in this compilation? Returns True if the set of references contains those assemblies needed for XML literals. If those assemblies are included, we should include the InternalXmlHelper SyntaxTree in the Compilation so the helper methods are available for binding XML. Compare two source locations, using their containing trees, and then by Span.First within a tree. Can be used to get a total ordering on declarations, for example. Compare two source locations, using their containing trees, and then by Span.First within a tree. Can be used to get a total ordering on declarations, for example. Compare two source locations, using their containing trees, and then by Span.First within a tree. Can be used to get a total ordering on declarations, for example. Gets the or for a metadata reference used to create this compilation. or corresponding to the given reference or Nothing if there is none. Uses object identity when comparing two references. Gets the that corresponds to the assembly symbol. Determine if enum arrays can be initialized using block initialization. True if it's safe to use block initialization for enum arrays. In NetFx 4.0, block array initializers do not work on all combinations of {32/64 X Debug/Retail} when array elements are enums. This is fixed in 4.5 thus enabling block array initialization for a very common case. We look for the presence of which was introduced in .NET Framework 4.5 Gets the AssemblySymbol that represents the assembly being created. Get a ModuleSymbol that refers to the module being created by compiling all of the code. By getting the GlobalNamespace property of that module, all of the namespace and types defined in source code can be obtained. Gets the merged root namespace that contains all namespaces and types defined in source code or in referenced metadata, merged into a single namespace hierarchy. This namespace hierarchy is how the compiler binds types that are referenced in code. Get the "root" or default namespace that all source types are declared inside. This may be the global namespace or may be another namespace. Given a namespace symbol, returns the corresponding namespace symbol with Compilation extent that refers to that namespace in this compilation. Returns Nothing if there is no corresponding namespace. This should not occur if the namespace symbol came from an assembly referenced by this compilation. Returns the list of member imports that apply to all syntax trees in this compilation. Returns the list of alias imports that apply to all syntax trees in this compilation. Determine what kind of conversion, if any, there is between the types "source" and "destination". A symbol representing the implicit Script class. This is null if the class is not defined in the compilation. Resolves a symbol that represents script container (Script class). Uses the full name of the container class stored in to find the symbol. The Script class symbol or null if it is not defined. Get symbol for predefined type from Cor Library referenced by this compilation. Get symbol for predefined type member from Cor Library referenced by this compilation. Lookup a type within the compilation's assembly and all referenced assemblies using its canonical CLR metadata name (names are compared case-sensitively). Symbol for the type or null if type cannot be found or is ambiguous. Get a fresh SemanticModel. Note that each invocation gets a fresh SemanticModel, each of which has a cache. Therefore, one effectively clears the cache by discarding the SemanticModel. Get all diagnostics for the entire compilation. This includes diagnostics from parsing, declarations, and the bodies of methods. Getting all the diagnostics is potentially a length operations, as it requires parsing and compiling all the code. The set of diagnostics is not caches, so each call to this method will recompile all methods. Cancellation token to allow cancelling the operation. Get parse diagnostics for the entire compilation. This includes diagnostics from parsing BUT NOT from declarations and the bodies of methods or initializers. The set of parse diagnostics is cached, so calling this method a second time should be fast. Get declarations diagnostics for the entire compilation. This includes diagnostics from declarations, BUT NOT the bodies of methods or initializers. The set of declaration diagnostics is cached, so calling this method a second time should be fast. Cancellation token to allow cancelling the operation. Get method body diagnostics for the entire compilation. This includes diagnostics only from the bodies of methods and initializers. These diagnostics are NOT cached, so calling this method a second time repeats significant work. Cancellation token to allow cancelling the operation. Get all errors in the compilation, up through the given compilation stage. Note that this may require significant work by the compiler, as all source code must be compiled to the given level in order to get the errors. Errors on Options should be inspected by the user prior to constructing the compilation. Returns all errors. The errors are not sorted in any particular order, and the client should sort the errors as desired. Return true if there is a source declaration symbol name that meets given predicate. Return source declaration symbols whose name meets given predicate. Return true if there is a source declaration symbol name that matches the provided name. This may be faster than when predicate is just a simple string check. is case insensitive. ReferenceManager encapsulates functionality to create an underlying SourceAssemblySymbol (with underlying ModuleSymbols) for Compilation and AssemblySymbols for referenced assemblies (with underlying ModuleSymbols) all properly linked together based on reference resolution between them. ReferenceManager is also responsible for reuse of metadata readers for imported modules and assemblies as well as existing AssemblySymbols for referenced assemblies. In order to do that, it maintains global cache for metadata readers and AssemblySymbols associated with them. The cache uses WeakReferences to refer to the metadata readers and AssemblySymbols to allow memory and resources being reclaimed once they are no longer used. The tricky part about reusing existing AssemblySymbols is to find a set of AssemblySymbols that are created for the referenced assemblies, which (the AssemblySymbols from the set) are linked in a way, consistent with the reference resolution between the referenced assemblies. When existing Compilation is used as a metadata reference, there are scenarios when its underlying SourceAssemblySymbol cannot be used to provide symbols in context of the new Compilation. Consider classic multi-targeting scenario: compilation C1 references v1 of Lib.dll and compilation C2 references C1 and v2 of Lib.dll. In this case, SourceAssemblySymbol for C1 is linked to AssemblySymbol for v1 of Lib.dll. However, given the set of references for C2, the same reference for C1 should be resolved against v2 of Lib.dll. In other words, in context of C2, all types from v1 of Lib.dll leaking through C1 (through method signatures, etc.) must be retargeted to the types from v2 of Lib.dll. In this case, ReferenceManager creates a special RetargetingAssemblySymbol for C1, which is responsible for the type retargeting. The RetargetingAssemblySymbols could also be reused for different Compilations, ReferenceManager maintains a cache of RetargetingAssemblySymbols (WeakReferences) for each Compilation. The only public entry point of this class is CreateSourceAssembly() method. VB allows two weak assembly references of the same simple name be passed to a compilation as long as their versions are different. It ignores culture. Creates a from specified metadata. Used by EnC to create symbols for emit baseline. The PE symbols are used by . The assembly references listed in the metadata AssemblyRef table are matched to the resolved references stored on this . We assume that the dependencies of the baseline metadata are the same as the dependencies of the current compilation. This is not exactly true when the dependencies use time-based versioning pattern, e.g. AssemblyVersion("1.0.*"). In that case we assume only the version changed And nothing else. Each AssemblyRef is matched against the assembly identities using an exact equality comparison modulo version. AssemblyRef with lower version in metadata is matched to a PE assembly symbol with the higher version (provided that the assembly name, culture, PKT And flags are the same) if there is no symbol with the exactly matching version. If there are multiple symbols with higher versions selects the one with the minimal version among them. Matching to a higher version is necessary to support EnC for projects whose P2P dependencies use time-based versioning pattern. The versions of the dependent projects seen from the IDE will be higher than the one written in the metadata at the time their respective baselines are built. No other unification or further resolution is performed. A map of the PE assembly symbol identities to the identities of the original metadata AssemblyRefs. This map will be used in emit when serializing AssemblyRef table of the delta. For the delta to be compatible with the original metadata we need to map the identities of the PE assembly symbols back to the original AssemblyRefs (if different). In other words, we pretend that the versions of the dependencies haven't changed. Guarded by . Import options of the compilation being built. For testing purposes only. For testing purposes only. An array of cached well known types available for use in this Compilation. Lazily filled by GetWellKnownType method. Lazy cache of well known members. Not yet known value is represented by ErrorTypeSymbol.UnknownResultType Synthesizes a custom attribute. Returns Nothing if the symbol is missing, or any of the members in are missing. The attribute is synthesized only if present. Takes a list of pairs of well-known members and constants. The constants will be passed to the field/property referenced by the well-known member. If the well-known member does Not exist in the compilation then no attribute will be synthesized. Indicates if this particular attribute application should be considered optional. Lookup member declaration in well known type used by this Compilation. In case duplicate types are encountered, returns an error type. But if the IgnoreCorLibraryDuplicatedTypes compilation option is set, any duplicate type found in corlib is ignored and doesn't count as a duplicate. Structure containing all semantic information about a for each statement. Gets the "GetEnumerator" method. Gets the "MoveNext" method. Gets the "Current" property. Gets the "Dispose" method. The intermediate type to which the output of the is converted before being converted to the iteration variable type. As you might hope, for an array, it is the element type of the array. The conversion from the to the iteration variable type. May be user-defined. The conversion from the type of the to the . Frequently the identity conversion. Initializes a new instance of the structure. The GetEnumerator method. The MoveNext method. The Current property. The Dispose method. This is an implementation of a special symbol comparer, which is supposed to be used for sorting original definition symbols (explicitly or explicitly declared in source within the same container) in lexical order of their declarations. It will not work on anything that uses non-source locations. Completes binding and performs analysis of bound trees for the purpose of obtaining diagnostics. NOTE: This method does not perform lowering/rewriting/emit. Errors from those stages require complete compile, but generally are not interesting during editing. NOTE: the bound tree produced by this method are not stored anywhere and immediately lost after diagnostics of a particular tree is done. Compiles given compilation into provided module. NOTE: it is ok for moduleBeingBuiltOpt to be Nothing. In such case the only results of this method would be diagnostics for complete compile. NOTE: the bound/lowered trees produced by this method are not stored anywhere and immediately lost after obtaining method bodies and diagnostics for a particular tree. Detects cycles in constructor invocations based on the 'constructor-calls-constructor' map provided in 'constructorCallMap', reports errors if found. NOTE: 'constructorCallMap' is being mutated by this method All the constructors in the cycle will be reported Compiles the method. If the method being compiled is a constructor, CompileMethod returns in this parameter the symbol of the constructor called from the one being compiled either explicitly or implicitly. For structure constructors calling parameterless constructor returns the synthesized constructor symbol. If any of the "Handles" in the list have synthetic WithEvent override as a container, then this method will (if not done already) inject property/accessors symbol into the emit module and assign bodies to the accessors. Assuming the statement is a constructor call wrapped in bound expression statement, get the method symbol being called Indicates whether the compiler accepted or rejected the method during overload resolution. Represents the results of overload resolution for a single method. The method or property considered during overload resolution. Indicates why the compiler accepted or rejected the method during overload resolution. Returns true if the compiler accepted this method as the sole correct result of overload resolution. Returns true if the method is considered in its expanded param array form. Summarizes the results of an overload resolution analysis. Describes whether overload resolution succeeded, and which method was selected if overload resolution succeeded. True if overload resolution successfully selected a single best method. If overload resolution successfully selected a single best method, returns information about that method. Otherwise returns Nothing. If there was a method that overload resolution considered better than all others, returns information about that method. A method may be returned even if that method was not considered a successful overload resolution, as long as it was better than any other potential method considered. Returns information about each method that was considered during overload resolution, and what the results of overload resolution were for that method. The symbol that was referred to by the identifier, if any. Returns the constant value associated with the symbol, if any. Instances of this can be exposed to external consumers. Other types of are not designed for direct exposure and their implementation might not be able to handle external requests properly. Optional AsQueryable/AsEnumerable/Cast(Of Object) method used to "convert" to queryable collection. Optional Select method to handle AsClause. SelectMany method for , which is not the first in a , and is not the first in . The first of the two optional Select methods associated with . The second of the two optional Select methods associated with . Allows asking semantic questions about a tree of syntax nodes in a Compilation. Typically, an instance is obtained by a call to Compilation.GetBinding. An instance of SemanticModel caches local symbols and semantic information. Thus, it is much more efficient to use a single instance of SemanticModel when asking multiple questions about a syntax tree, because information from the first question may be reused. This also means that holding onto an instance of SemanticModel for a long time may keep a significant amount of memory from being garbage collected. When an answer is a named symbol that is reachable by traversing from the root of the symbol table, (that is, from an AssemblySymbol of the Compilation), that symbol will be returned (i.e. the returned value will be reference-equal to one reachable from the root of the symbol table). Symbols representing entities without names (e.g. array-of-int) may or may not exhibit reference equality. However, some named symbols (such as local variables) are not reachable from the root. These symbols are visible as answers to semantic questions. When the same SemanticModel object is used, the answers exhibit reference-equality. Returns information about methods associated with CollectionRangeVariableSyntax. Returns information about methods associated with AggregateClauseSyntax. DistinctClauseSyntax - Returns Distinct method associated with DistinctClauseSyntax. WhereClauseSyntax - Returns Where method associated with WhereClauseSyntax. PartitionWhileClauseSyntax - Returns TakeWhile/SkipWhile method associated with PartitionWhileClauseSyntax. PartitionClauseSyntax - Returns Take/Skip method associated with PartitionClauseSyntax. GroupByClauseSyntax - Returns GroupBy method associated with GroupByClauseSyntax. JoinClauseSyntax - Returns Join/GroupJoin method associated with JoinClauseSyntax/GroupJoinClauseSyntax. SelectClauseSyntax - Returns Select method associated with SelectClauseSyntax, if needed. FromClauseSyntax - Returns Select method associated with FromClauseSyntax, which has only one CollectionRangeVariableSyntax and is the only query clause within QueryExpressionSyntax. NotNeeded SymbolInfo otherwise. The method call is injected by the compiler to make sure that query is translated to at least one method call. LetClauseSyntax - NotNeeded SymbolInfo. OrderByClauseSyntax - NotNeeded SymbolInfo. AggregateClauseSyntax - Empty SymbolInfo. GetAggregateClauseInfo should be used instead. Returns Select method associated with ExpressionRangeVariableSyntax within a LetClauseSyntax, if needed. NotNeeded SymbolInfo otherwise. Returns aggregate function associated with FunctionAggregationSyntax. Returns OrderBy/OrderByDescending/ThenBy/ThenByDescending method associated with OrderingSyntax. The compilation associated with this binding. The root node of the syntax tree that this binding is based on. Gets symbol information about an expression syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets symbol information about the 'Add' method corresponding to an expression syntax within collection initializer. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called and the is in the right place in the syntax tree. Gets symbol information about an attribute syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets type information about an expression syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets type information about an attribute syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets constant value information about an expression syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets member group information about an expression syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets member group information about an attribute syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that CheckSyntaxNode has already been called. Gets symbol information about a cref reference syntax node. This is the worker function that is overridden in various derived kinds of Semantic Models. Returns what symbol(s), if any, the given expression syntax bound to in the program. An AliasSymbol will never be returned by this method. What the alias refers to will be returned instead. To get information about aliases, call GetAliasInfo. If binding the type name C in the expression "new C(...)" the actual constructor bound to will be returned (or all constructor if overload resolution failed). This occurs as long as C unambiguously binds to a single type that has a constructor. If C ambiguously binds to multiple types, or C binds to a static class, then type(s) are returned. Returns what 'Add' method symbol(s), if any, corresponds to the given expression syntax within . Returns what symbol(s), if any, the given cref reference syntax bound to in the documentation comment. An AliasSymbol will never be returned by this method. What the alias refers to will be returned instead. Binds the expression in the context of the specified location and get semantic information such as type, symbols and diagnostics. This method is used to get semantic information about an expression that did not actually appear in the source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed expression. This syntax node need not and typically does not appear in the source code referred to SemanticModel instance. Indicates whether to binding the expression as a full expressions, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The semantic information for the topmost node of the expression. The passed in expression is interpreted as a stand-alone expression, as if it appeared by itself somewhere within the scope that encloses "position". Bind the attribute in the context of the specified location and get semantic information such as type, symbols and diagnostics. This method is used to get semantic information about an attribute that did not actually appear in the source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. In order to obtain the correct scoping rules for the attribute, position should be the Start position of the Span of the symbol that the attribute is being applied to. A syntax node that represents a parsed attribute. This syntax node need not and typically does not appear in the source code referred to SemanticModel instance. The semantic information for the topmost node of the attribute. Gets type information about an expression. The syntax node to get type information for. Binds the expression in the context of the specified location and gets type information. This method is used to get type information about an expression that did not actually appear in the source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed expression. This syntax node need not and typically does not appear in the source code referred to by the SemanticModel instance. Indicates whether to binding the expression as a full expressions, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The type information for the topmost node of the expression. The passed in expression is interpreted as a stand-alone expression, as if it appeared by itself somewhere within the scope that encloses "position". Gets the conversion that occurred between the expression's type and type implied by the expression's context. Gets the conversion that occurred between the expression's type and type implied by the expression's context. Binds the expression in the context of the specified location and gets constant value information. This method is used to get information about an expression that did not actually appear in the source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed expression. This syntax node need not and typically does not appear in the source code referred to by SemanticModel instance. The passed in expression is interpreted as a stand-alone expression, as if it appeared by itself somewhere within the scope that encloses "position". If "nameSyntax" resolves to an alias name, return the AliasSymbol corresponding to A. Otherwise return null. Binds the name in the context of the specified location and sees if it resolves to an alias name. If it does, return the AliasSymbol corresponding to it. Otherwise, return null. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a name. This syntax node need not and typically does not appear in the source code referred to by the SemanticModel instance. Indicates whether to binding the name as a full expression, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The passed in name is interpreted as a stand-alone name, as if it appeared by itself somewhere within the scope that encloses "position". Gets the binder that encloses the position. See comment on LookupSymbols for how positions are interpreted. When doing speculative binding, we don't have any context information about expressions or the context that is expected. We try to interpret as a value, but only if it doesn't cause additional errors (indicating that it wasn't value to interpret it that way). This should get us the most "liberal" interpretation for semantic information. Bind the given attribute speculatively at the given position, and return back the resulting bound node. May return null in some error cases. Bind the given attribute speculatively at the given position, and return back the resulting bound node summary. May return null in some error cases. In cases where we are binding C in "[C(...)]", the bound nodes return the symbol for the type. However, we've decided that we want this case to return the constructor of the type instead (based on the SemanticInfoOptions. This affects only attributes. This method checks for this situation and adjusts the syntax and method group. Gets the available named symbols in the context of the specified location And optional container. Only symbols that are accessible And visible from the given location are returned. The character position for determining the enclosing declaration scope And accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position Is used. The name of the symbol to find. If null Is specified then symbols with any names are returned. Consider (reduced) extension methods. A list of symbols that were found. If no symbols were found, an empty list Is returned. The "position" Is used to determine what variables are visible And accessible. Even if "container" Is specified, the "position" location Is significant for determining which members of "containing" are accessible. Labels are Not considered (see ). Non-reduced extension methods are considered regardless of the value of . Gets the available base type members in the context of the specified location. Akin to calling with the container set to the immediate base type of the type in which occurs. However, the accessibility rules are different: protected members of the base type will be visible. Consider the following example: Public Class Base Protected Sub M() End Sub End Class Public Class Derived : Inherits Base Sub Test(b as Base) b.M() ' Error - cannot access protected member. MyBase.M() End Sub End Class Protected members of an instance of another type are only accessible if the instance is known to be "this" instance (as indicated by the "MyBase" keyword). The character position for determining the enclosing declaration scope and accessibility. The name of the symbol to find. If null is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Non-reduced extension methods are considered, but reduced extension methods are not. Gets the available named static member symbols in the context of the specified location And optional container. Only members that are accessible And visible from the given location are returned. Non-reduced extension methods are considered, since they are static methods. The character position for determining the enclosing declaration scope And accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position Is used. The name of the symbol to find. If null Is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list Is returned. The "position" Is used to determine what variables are visible And accessible. Even if "container" Is specified, the "position" location Is significant for determining which members of "containing" are accessible. Gets the available named namespace And type symbols in the context of the specified location And optional container. Only members that are accessible And visible from the given location are returned. The character position for determining the enclosing declaration scope And accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position Is used. The name of the symbol to find. If null Is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list Is returned. The "position" Is used to determine what variables are visible And accessible. Even if "container" Is specified, the "position" location Is significant for determining which members of "containing" are accessible. Does Not return INamespaceOrTypeSymbol, because there could be aliases. Gets the available named label symbols in the context of the specified location And optional container. Only members that are accessible And visible from the given location are returned. The character position for determining the enclosing declaration scope And accessibility. The name of the symbol to find. If null Is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list Is returned. The "position" Is used to determine what variables are visible And accessible. Even if "container" Is specified, the "position" location Is significant for determining which members of "containing" are accessible. Gets the available named symbols in the context of the specified location and optional container. Only symbols that are accessible and visible from the given location are returned. The character position for determining the enclosing declaration scope and accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position is used. The name of the symbol to find. If null is specified then symbols with any names are returned. Additional options that affect the lookup process. Ignore 'throughType' in accessibility checking. Used in checking accessibility of symbols accessed via 'MyBase' or 'base'. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Even if "container" is specified, the "position" location is significant for determining which members of "containing" are accessible. Locations are character locations, just as used as the Syntax APIs such as FindToken, or returned from the Span property on tokens and syntax node. The text of the program is divided into scopes, which nest but don't otherwise intersect. When doing an operation such as LookupSymbols, the code first determines the smallest scope containing the position, and from there all containing scopes. Scopes that span an entire block statement start at the beginning of the first token of the block header, and end immediately before the statement terminator token following the end statement of the block. If the end statement of the block is missing, it ends immediately before the next token. Examples of these include members and type parameters of a type, type parameters of a method, and variables declared in a For statement. Scopes that span the interior of a block statement start at the statement terminator of the block header statement, and end immediately before the first token of the end statement of the block. If the end statement of the block is missing, it ends immediately before the next statement. Examples of these include local variables, method parameters, and members of a namespace. Scopes of variables declared in a single-line If statement start at the beginning of the "Then" token, and end immediately before the Else token or statement terminator. Scopes of variables declared in the Else part of a single-line If start at the beginning of the "Else" token, and end immediately before the statement terminator. Some specialized binding rules are in place for a single statement, like Imports or Inherits. These specialized binding rules begin at the start of the first token of the statement, and end immediately before the statement terminator of that statement. In all of the above, the "start" means the start of a token without considering leading trivia. In other words, Span.Start, not FullSpan.Start. With the exception of documentation comments, all scopes begin at the start of a token, and end immediately before the start of a token. The scope of the default namespace, and all symbols introduced via Imports statements, is the entire file. Positions within a documentation comment that is correctly attached to a symbol take on the binding scope of that symbol. Throws an argument exception if the passed lookup options are invalid. Gets the names of the available named symbols in the context of the specified location and optional container. Only symbols that are accessible and visible from the given location are returned. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. The container to search for symbols within. If null then the enclosing declaration scope around position is used. Additional options that affect the lookup process. The "position" is used to determine what variables are visible and accessible. Even if "container" is specified, the "position" location is significant for determining which members of "containing" are accessible. Determines if the symbol is accessible from the specified location. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. The symbol that we are checking to see if it accessible. True if "symbol is accessible, false otherwise. This method only checks accessibility from the point of view of the accessibility modifiers on symbol and its containing types. Even if true is returned, the given symbol may not be able to be referenced for other reasons, such as name hiding. Analyze control-flow within a part of a method body. The first statement to be included in the analysis. The last statement to be included in the analysis. An object that can be used to obtain the result of the control flow analysis. The two statements are not contained within the same statement list. Analyze control-flow within a part of a method body. The statement to be included in the analysis. An object that can be used to obtain the result of the control flow analysis. Analyze data-flow within an expression. The expression within the associated SyntaxTree to analyze. An object that can be used to obtain the result of the data flow analysis. Analyze data-flow within a set of contiguous statements. The first statement to be included in the analysis. The last statement to be included in the analysis. An object that can be used to obtain the result of the data flow analysis. The two statements are not contained within the same statement list. Analyze data-flow within a statement. The statement to be included in the analysis. An object that can be used to obtain the result of the data flow analysis. Get a SemanticModel object that is associated with a method body that did not appear in this source code. Given must lie within an existing method body of the Root syntax node for this SemanticModel. Locals and labels declared within this existing method body are not considered to be in scope of the speculated method body. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel and must be within the FullSpan of a Method body within the Root syntax node. A syntax node that represents a parsed method declaration. This method should not be present in the syntax tree associated with this object, but must have identical signature to the method containing the given in this SemanticModel. A SemanticModel object that can be used to inquire about the semantic information associated with syntax nodes within . Flag indicating whether a speculative semantic model was created. Throws this exception if the node is contained any SyntaxTree in the current Compilation. Throws this exception if is null. Throws this exception if this model is a speculative semantic model, i.e. is True. Chaining of speculative semantic model is not supported. Get a SemanticModel object that is associated with a range argument syntax that did not appear in this source code. This can be used to get detailed semantic information about sub-parts of this node that did not appear in source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed RangeArgumentSyntax node. This node should not be present in the syntax tree associated with this object. A SemanticModel object that can be used to inquire about the semantic information associated with syntax nodes within . Flag indicating whether a speculative semantic model was created. Throws this exception if the node is contained any SyntaxTree in the current Compilation. Throws this exception if is null. Throws this exception if this model is a speculative semantic model, i.e. is True. Chaining of speculative semantic model is not supported. Get a SemanticModel object that is associated with an executable statement that did not appear in this source code. This can be used to get detailed semantic information about sub-parts of a statement that did not appear in source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed statement. This statement should not be present in the syntax tree associated with this object. A SemanticModel object that can be used to inquire about the semantic information associated with syntax nodes within . Flag indicating whether a speculative semantic model was created. Throws this exception if the node is contained any SyntaxTree in the current Compilation. Throws this exception if is null. Throws this exception if this model is a speculative semantic model, i.e. is True. Chaining of speculative semantic model is not supported. Get a SemanticModel object that is associated with an initializer that did not appear in this source code. This can be used to get detailed semantic information about sub-parts of a field initializer, property initializer or default parameter value that did not appear in source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed initializer. This initializer should not be present in the syntax tree associated with this object. A SemanticModel object that can be used to inquire about the semantic information associated with syntax nodes within . Flag indicating whether a speculative semantic model was created. Throws this exception if the node is contained any SyntaxTree in the current Compilation. Throws this exception if is null. Throws this exception if this model is a speculative semantic model, i.e. is True. Chaining of speculative semantic model is not supported. Get a SemanticModel object that is associated with an attribute that did not appear in this source code. This can be used to get detailed semantic information about sub-parts of an attribute that did not appear in source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed attribute. This attribute should not be present in the syntax tree associated with this object. A SemanticModel object that can be used to inquire about the semantic information associated with syntax nodes within . Flag indicating whether a speculative semantic model was created. Throws this exception if the node is contained any SyntaxTree in the current Compilation. Throws this exception if is null. Throws this exception if this model is a speculative semantic model, i.e. is True. Chaining of speculative semantic model is not supported. Get a SemanticModel object that is associated with a type syntax that did not appear in this source code. This can be used to get detailed semantic information about sub-parts of a type syntax that did not appear in source code. A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed type syntax. This expression should not be present in the syntax tree associated with this object. Indicates whether to bind the expression as a full expression, or as a type or namespace. A SemanticModel object that can be used to inquire about the semantic information associated with syntax nodes within . Flag indicating whether a speculative semantic model was created. Throws this exception if the node is contained any SyntaxTree in the current Compilation. Throws this exception if this model is a speculative semantic model, i.e. is True. Chaining of speculative semantic model is not supported. If this is a speculative semantic model, then returns its parent semantic model. Otherwise, returns null. Determines what type of conversion, if any, would be used if a given expression was converted to a given type. An expression which must occur within the syntax tree associated with this object. The type to attempt conversion to. Returns a Conversion object that summarizes whether the conversion was possible, and if so, what kind of conversion it was. If no conversion was possible, a Conversion object with a false "Exists " property is returned. To determine the conversion between two types (instead of an expression and a type), use Compilation.ClassifyConversion. Determines what type of conversion, if any, would be used if a given expression was converted to a given type. The character position for determining the enclosing declaration scope and accessibility. An expression to classify. This expression does not need to be present in the syntax tree associated with this object. The type to attempt conversion to. Returns a Conversion object that summarizes whether the conversion was possible, and if so, what kind of conversion it was. If no conversion was possible, a Conversion object with a false "Exists " property is returned. To determine the conversion between two types (instead of an expression and a type), use Compilation.ClassifyConversion. Given a modified identifier that is part of a variable declaration, get the corresponding symbol. The modified identifier that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Gets the corresponding symbol for a specified tuple element. A TupleElementSyntax object. A cancellation token. A symbol, for the specified element; otherwise Nothing. Given a FieldInitializerSyntax, get the corresponding symbol of anonymous type property. The anonymous object creation field initializer syntax. The symbol that was declared, or Nothing if no such symbol exists or if the field initializer was not part of an anonymous type creation. Given an AnonymousObjectCreationExpressionSyntax, get the corresponding symbol of anonymous type. The anonymous object creation syntax. The symbol that was declared, or Nothing if no such symbol exists. Given an ExpressionRangeVariableSyntax, get the corresponding symbol. The range variable syntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given a CollectionRangeVariableSyntax, get the corresponding symbol. The range variable syntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given an AggregationRangeVariableSyntax, get the corresponding symbol. The range variable syntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given a label statement, get the corresponding label symbol. The label statement. The label symbol, or Nothing if no such symbol exists. Given a declarationSyntax that is part of a enum constant declaration, get the corresponding symbol. The declarationSyntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given a type declaration, get the corresponding type symbol. The syntax node that declares a type. The type symbol that was declared. Given a type block, get the corresponding type symbol. The syntax node that declares a type block. The type symbol that was declared. Given a enum declaration, get the corresponding type symbol. The syntax node that declares an enum. The type symbol that was declared. Given a enum block, get the corresponding type symbol. The syntax node that declares an enum block. The type symbol that was declared. Given a namespace declaration, get the corresponding type symbol. The syntax node that declares a namespace. The namespace symbol that was declared. Given a namespace block, get the corresponding type symbol. The syntax node that declares a namespace block. The namespace symbol that was declared. Given a method, property, or event declaration, get the corresponding symbol. The syntax node that declares a method, property, or event. The method, property, or event symbol that was declared. Given a parameter declaration, get the corresponding parameter symbol. The syntax node that declares a parameter. The parameter symbol that was declared. Given a type parameter declaration, get the corresponding type parameter symbol. The syntax node that declares a type parameter. The type parameter symbol that was declared. Given a delegate statement syntax get the corresponding named type symbol. The syntax node that declares a delegate. The named type that was declared. Given a constructor statement syntax get the corresponding method symbol. The syntax node that declares a constructor. The method symbol that was declared. Given a method statement syntax get the corresponding method symbol. The syntax node that declares a method. The method symbol that was declared. Given a method statement syntax get the corresponding method symbol. The syntax node that declares a method. The method symbol that was declared. Given a operator statement syntax get the corresponding method symbol. The syntax node that declares an operator. The method symbol that was declared. Given a method block syntax get the corresponding method, property or event symbol. The syntax node that declares method, property or event. The method, property or event symbol that was declared. Given a property statement syntax get the corresponding property symbol. The syntax node that declares a property. The property symbol that was declared. Given an event statement syntax get the corresponding event symbol. The syntax node that declares an event. The event symbol that was declared. Given a property block syntax get the corresponding property symbol. The syntax node that declares property. The property symbol that was declared. Given a custom event block syntax get the corresponding event symbol. The syntax node that declares the custom event. The event symbol that was declared. Given a catch statement syntax get the corresponding local symbol. The catch statement syntax node. The local symbol that was declared by the Catch statement or Nothing if statement does not declare a local variable. Given a property block syntax get the corresponding property symbol. The syntax node that declares property. The property symbol that was declared. Given an import clause get the corresponding symbol for the import alias that was introduced. The import statement syntax node. The alias symbol that was declared or Nothing if no alias symbol was declared. Given a field declaration syntax, get the corresponding symbols. The syntax node that declares one or more fields. The field symbols that were declared. Gets bound node summary of the underlying invocation in a case of RaiseEvent RaiseEvent situation is very special: 1) Unlike other syntaxes that take named arguments, RaiseEvent is a statement. 2) RaiseEvent is essentially a wrapper around underlying call to the event rising method. Note that while event itself may have named parameters in its syntax, their names could be irrelevant For the purpose of fetching named parameters, it is the target of the call that we are interested in. === Example: Interface I1 Event E(qwer As Integer) End Interface Class cls1 : Implements I1 Event E3(bar As Integer) Implements I1.E ' "bar" means nothing here. Only type matters. Sub moo() RaiseEvent E3(qwer:=123) ' qwer binds to parameter on I1.EEventhandler.invoke(goo) End Sub End Class The SyntaxTree that is bound Gets the semantic information of a for each statement. The for each syntax node. Gets the semantic information of a for each statement. The for block syntax node. Gets the semantic information of a for each statement. The for each syntax node. Gets the semantic information of an Await expression. If the given node is within a preprocessing directive, gets the preprocessing symbol info for it. Preprocessing symbol identifier node. Options to control the internal working of GetSemanticInfoWorker. Not currently exposed to public clients, but could be if desired. When binding "C" new C(...), return the type C and do not return information about which constructor was bound to. Bind "new C(...)" to get information about which constructor was chosen. When binding "C" new C(...), return the constructor of C that was bound to, if C unambiguously binds to a single type with at least one constructor. When binding a name X that was declared with a "using X=OtherTypeOrNamespace", return OtherTypeOrNamespace. When binding a name X that was declared with a "using X=OtherTypeOrNamespace", return the alias symbol X. Given a position in the SyntaxTree for this SemanticModel returns the innermost Symbol that the position is considered inside of. Get the state of Option Strict for the code covered by this semantic model. This takes into effect both file-level "Option Strict" statements and the project-level defaults. Get the state of Option Infer for the code covered by this semantic model. This takes into effect both file-level "Option Infer" statements and the project-level defaults. True if Option Infer On, False if Option Infer Off. Get the state of Option Explicit for the code covered by this semantic model. This takes into effect both file-level "Option Explicit" statements and the project-level defaults. True if Option Explicit On, False if Option Explicit Off. Get the state of Option Compare for the code covered by this semantic model. This takes into effect both file-level "Option Compare" statements and the project-level defaults. True if Option Compare Text, False if Option Compare Binary. Instances of this type represent user-facing speculative semantic models that are backed by internal . Allows asking semantic questions about a tree of syntax nodes that did not appear in the original source code. Typically, an instance is obtained by a call to SemanticModel.TryGetSpeculativeSemanticModel. Allows asking semantic questions about any node in a SyntaxTree within a Compilation. The compilation associated with this binding. The root node of the syntax tree that this binding is based on. The SyntaxTree that is bound Returns true if this Is a SemanticModel that ignores accessibility rules when answering semantic questions. Get all the errors within the syntax tree associated with this object. Includes errors involving compiling method bodies or initializers, in addition to the errors returned by GetDeclarationDiagnostics and parse errors. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. Because this method must semantically analyze all method bodies and initializers to check for diagnostics, it may take a significant amount of time. Unlike GetDeclarationDiagnostics, diagnostics for method bodies and initializers are not cached, the any semantic information used to obtain the diagnostics is discarded. Get all of the syntax errors within the syntax tree associated with this object. Does not get errors involving declarations or compiling method bodies or initializers. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. Get all the syntax and declaration errors within the syntax tree associated with this object. Does not get errors involving compiling method bodies or initializers. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. The declaration errors for a syntax tree are cached. The first time this method is called, a ll declarations are analyzed for diagnostics. Calling this a second time will return the cached diagnostics. Get all the syntax and declaration errors within the syntax tree associated with this object. Does not get errors involving compiling method bodies or initializers. Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. The declaration errors for a syntax tree are cached. The first time this method is called, a ll declarations are analyzed for diagnostics. Calling this a second time will return the cached diagnostics. Get symbols referenced from 'cref' or 'name' attribute value. Node to bind. True to leave s, False to unwrap them. Out: symbols that would have been in the return value but improperly refer to type parameters. Referenced symbols, less type parameters. Checks all symbol locations against the syntax provided and return symbol if any of the locations is inside the syntax span. Returns Nothing otherwise. Given a delegate declaration, get the corresponding type symbol. The syntax node that declares a type. The type symbol that was declared. Given a type declaration, get the corresponding type symbol. The syntax node that declares a type. The type symbol that was declared. Given a enum declaration, get the corresponding type symbol. The syntax node that declares an enum. The type symbol that was declared. Given a namespace declaration, get the corresponding type symbol. The syntax node that declares a namespace. The namespace symbol that was declared. Given a method, property, or event declaration, get the corresponding symbol. The syntax node that declares a method, property, or event. The method, property, or event symbol that was declared. Given a parameter declaration, get the corresponding parameter symbol. The syntax node that declares a parameter. The parameter symbol that was declared. Given a type parameter declaration, get the corresponding type parameter symbol. The syntax node that declares a type parameter. The type parameter symbol that was declared. Given a variable declaration, get the corresponding symbol. The syntax node that declares a variable. The symbol that was declared. Given a FieldInitializerSyntax, get the corresponding symbol of anonymous type creation. The anonymous object creation field initializer syntax. The symbol that was declared, or Nothing if no such symbol exists. Given an AnonymousObjectCreationExpressionSyntax, get the corresponding symbol of anonymous type. The anonymous object creation syntax. The symbol that was declared, or Nothing if no such symbol exists. Given an ExpressionRangeVariableSyntax, get the corresponding symbol. The range variable syntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given a CollectionRangeVariableSyntax, get the corresponding symbol. The range variable syntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given an AggregationRangeVariableSyntax, get the corresponding symbol. The range variable syntax that declares a variable. The symbol that was declared, or Nothing if no such symbol exists. Given an import clause get the corresponding symbol for the import alias that was introduced. The import statement syntax node. The alias symbol that was declared or Nothing if no alias symbol was declared. Given a field declaration syntax, get the corresponding symbols. The syntax node that declares one or more fields. The field symbols that were declared. Determines what type of conversion, if any, would be used if a given expression was converted to a given type. An expression which much occur within the syntax tree associated with this object. The type to attempt conversion to. Returns a Conversion object that summarizes whether the conversion was possible, and if so, what kind of conversion it was. If no conversion was possible, a Conversion object with a false "Exists " property is returned. To determine the conversion between two types (instead of an expression and a type), use Compilation.ClassifyConversion. Analyze control-flow within a part of a method body. The first statement to be included in the analysis. The last statement to be included in the analysis. An object that can be used to obtain the result of the control flow analysis. The two statements are not contained within the same statement list. The first statement to be included in the analysis. The first statement to be included in the analysis. The last statement to be included in the analysis. An object that can be used to obtain the result of the data flow analysis. The two statements are not contained within the same statement list. Analyze data-flow within an expression. The expression within the associated SyntaxTree to analyze. An object that can be used to obtain the result of the data flow analysis. Checks if the node is inside the attribute arguments Check Expression for being in right context, for example 'For ... Next [x]' is not correct context Check ForBlockSyntax for being the uppermost For block. By uppermost For block we mean that if Next clause contains several control variables, the uppermost block is the one which includes all the For blocks ending with the same Next clause Gets the semantic information of a for each statement. The for each syntax node. Used to create a region analysis context with failed flag set to be used in 'failed' scenarios When compiling in metadata-only mode, is not run. This is problematic because adds synthesized explicit implementations to the list of synthesized definitions. In lieu of running , this class performs a quick traversal of the symbol table and performs processing of synthesized symbols if necessary. Traverse the symbol table and properly add/process synthesized extra metadata if needed. Represents the state of compilation of one particular type. This includes, for example, a collection of synthesized methods created during lowering. WARNING: Note that the underlying collection classes are not thread-safe and this will need to be revised if emit phase is changed to support multithreading when translating a particular type. Method's information Flat array of created methods, non-empty if not-nothing A mapping from (source) iterator or async methods to the compiler-generated classes that implement them. Map of 'MyBase' or 'MyClass' call wrappers; actually each method symbol will only need one wrapper to call it non-virtually; Indeed, if the type have a virtual method M1 overridden, MyBase.M1 will use a wrapper for base type's method and MyClass.M1 a wrapper for this type's method. And if the type does not override a virtual method M1, both MyBase.M1 and MyClass.M1 will use a wrapper for base type's method. Is there any content in the methods collection. Method created with their bodies Free resources The type of the expression represented by the syntax node. For expressions that do not have a type, null is returned. If the type could not be determined due to an error, than an object derived from ErrorTypeSymbol is returned. The type of the expression after it has undergone an implicit conversion. If the type did not undergo an implicit conversion, returns the same as Type. If the expression underwent an implicit conversion, return information about that conversion. Otherwise, returns an identity conversion. Guess the non-error type that the given type was intended to represent, or return the type itself. If a single, non-ambiguous type is a guess-type inside the type symbol, return that; otherwise return the type itself (even if it is an error type). Represents a reference to another Visual Basic compilation. Returns the referenced . Create a metadata reference to a compilation. The compilation to reference. Should interop types be embedded in the created assembly? Namespace aliases for this reference. Applies Visual Basic-specific modification and filtering of s. Modifies an input per the given options. For example, the severity may be escalated, or the may be filtered out entirely (by returning null). The input diagnostic How warning diagnostics should be reported How specific diagnostics should be reported A diagnostic updated to reflect the options, or null if it has been filtered out Take a warning And return the final disposition of the given warning, based on both command line options And pragmas. The diagnostic options have precedence in the following order: 1. Warning level 2. Command line options (/nowarn, /warnaserror) 3. Custom severity configuration applied by analyzer 4. Editor config options (syntax tree level) 5. Global analyzer config options (compilation level) 6. Global warning level Global overrides are complicated. Global options never override suppression. Even if you have generalDiagnosticOption = ReportDiagnostic.Error, a suppressed diagnostic will not turn into an error. However, general diagnostic options do override warnings and infos into suppressions, i.e. if you had a syntaxtree option to turn a diagnostic into a warning, and the global option was Suppress, the diagnostic would be suppressed. Pragmas are considered separately. If a diagnostic would not otherwise be suppressed, but is suppressed by a pragma, is true but the diagnostic is not reported as suppressed. Returns documentation comment for a type, field, property, event or method, discards all the diagnostics Returns Nothing if there is no documentation comment on the type or there were errors preventing such a comment from being generated, XML string otherwise Returns true if the correct constructor is found or if the type is not defined at all, in which case it can be synthesized. HotReloadException type. May be created even if not used. We might find out we need it late in the emit phase only after all types and members have been compiled. indicates if the type is actually used in the delta. True if usage of HotReloadException type symbol has been observed and shouldn't be changed anymore. True if HotReloadException type is actually used in the delta. Matches symbols from an assembly in one compilation to the corresponding assembly in another. Assumes that only one assembly has changed between the two compilations. Match local declarations to names to generate a map from declaration to local slot. The names are indexed by slot And the assumption Is that declarations are in the same order as slots. Represents a reference to a generic method instantiation, closed over type parameters, e.g. MyNamespace.Class.Method{T}() Represents a reference to a generic type instantiation that is not nested. e.g. MyNamespace.A{int} Represents a reference to a generic type instantiation that is nested in a non-generic type. e.g. A.B{int} Represents a reference to a generic type instantiation. Subclasses represent nested and namespace types. Returns true if the type can be embedded. If the type is defined in a linked (/l-ed) assembly, but doesn't meet embeddable type requirements, this function returns False and reports appropriate diagnostics. This is a cache of a subset of . We don't include manifest resources in ref assemblies This value will override m_SourceModule.MetadataName. This functionality exists for parity with C#, which requires it for legacy reasons (see Microsoft.CodeAnalysis.CSharp.Emit.PEAssemblyBuilderBase.metadataName). True if conditional calls may be omitted when the required preprocessor symbols are not defined. Only false in debugger scenarios (where calls should never be omitted). Ignore accessibility when resolving well-known type members, in particular for generic type arguments (e.g.: binding to internal types in the EE). Builds an array of public type symbols defined in netmodules included in the compilation And type forwarders defined in this compilation Or any included netmodule (in this order). Returns a set of top-level forwarded types Stores collection of all embedded symbols referenced from IL Adds a symbol to the collection of referenced embedded symbols Represents a reference to a field of a generic type instantiation. e.g. A{int}.Field A{int}.B{string}.C.Field Represents a generic method of a generic type instantiation, closed over type parameters. e.g. A{T}.M{S}() A.B{T}.C.M{S}() Represents a reference to an instantiation of a generic type nested in an instantiation of another generic type. e.g. A{int}.B{string} A.B{int}.C.D{string} Represents a method of a generic type instantiation. e.g. A{int}.M() A.B{int}.C.M() Represents a reference to a type nested in an instantiation of a generic type. e.g. A{int}.B A.B{int}.C.D The base class for all symbols (namespaces, classes, method, parameters, etc.) that are exposed by the compiler. Return whether the symbol is either the original definition or distinct from the original. Intended for use in Debug.Assert only since it may include a deep comparison. Returns a list of attributes to emit to CustomAttribute table. Checks if this symbol is a definition and its containing module is a SourceModuleSymbol. Determine if two methods have the same signature according to section 4.1.1 of the VB language spec. The name, number of type parameters, and number and types of the method's non-optional parameters are considered. ByRef/Byval, parameter names, returns type, constraints, or optional parameters are not considered. Checks if is accessible from within type . The symbol for the accessibility check. The type to use as a context for the check. The type of an expression that is accessed off of, if any. This is needed to properly check accessibility of protected members. Checks if is accessible from within the assembly ', but outside any type. Protected members are deemed inaccessible. The symbol to check accessibility. The assembly to check accessibility within. True if symbol is accessible. False otherwise. Gets the name of this symbol. Returns the name of this symbol. Symbols without a name return the empty string; Nothing is never returned. Gets the name of a symbol as it appears in metadata. Most of the time, this is the same as the Name property, with the following exceptions: 1) The metadata name of generic types includes the "`1", "`2" etc. suffix that indicates the number of type parameters (it does not include, however, names of containing types or namespaces). 2) The metadata name of methods that overload or override methods with the same case-insensitive name but different case-sensitive names are adjusted so that the overrides and overloads always have the same name in a case-sensitive way. It should be noted that Visual Basic merges namespace declaration from source and/or metadata with different casing into a single namespace symbol. Thus, for namespace symbols this property may return incorrect information if multiple declarations with different casing were found. Gets the token for this symbol as it appears in metadata. Most of the time this Is 0, as it Is when the symbol Is Not loaded from metadata. Set the metadata name for this symbol. Called from for each symbol of the same name in a type. Gets the kind of this symbol. Get the symbol that logically contains this symbol. Gets the nearest enclosing namespace for this namespace or type. For a nested type, returns the namespace that contains its container. Returns the nearest lexically enclosing type, or Nothing if there is none. Returns the containing type or namespace, if this symbol is immediately contained by it. Otherwise returns Nothing. Returns the assembly containing this symbol. If this symbol is shared across multiple assemblies, or doesn't belong to an assembly, returns Nothing. For a source assembly, the associated compilation. For any other assembly, null. For a source module, the DeclaringCompilation of the associated source assembly. For any other module, null. For any other symbol, the DeclaringCompilation of the associated module. We're going through the containing module, rather than the containing assembly, because of /addmodule (symbols in such modules should return null). Remarks, not "ContainingCompilation" because it isn't transitive. Returns the module containing this symbol. If this symbol is shared across multiple modules, or doesn't belong to a module, returns Nothing. Get the original definition of this symbol. If this symbol is derived from another symbol by (say) type substitution, this gets the original symbol, as it was defined in source or metadata. Returns true if this is the original definition of this symbol. Get a source location key for sorting. For performance, it's important that this be able to be returned from a symbol without doing any additional allocations (even if nothing is cached yet.) Only (original) source symbols and namespaces that can be merged need override this function if they want to do so for efficiency. Gets the locations where this symbol was originally defined, either in source or metadata. Some symbols (for example, partial classes) may be defined in more than one location. Get the syntax node(s) where this symbol was declared in source. Some symbols (for example, partial classes) may be defined in more than one location. This property should return one or more syntax nodes only if the symbol was declared in source code and also was not implicitly declared (see the IsImplicitlyDeclared property). Note that for namespace symbol, the declaring syntax might be declaring a nested namespace. For example, the declaring syntax node for N1 in "Namespace N1.N2" is the NamespaceDeclarationSyntax for N1.N2. For the project namespace, the declaring syntax will be the CompilationUnitSyntax. The syntax node(s) that declared the symbol. If the symbol was declared in metadata or was implicitly declared, returns an empty read-only array. To go the opposite direction (from syntax node to symbol), see . Helper for implementing DeclaringSyntaxNodes for derived classes that store a location but not a SyntaxNode or SyntaxReference. Helper for implementing DeclaringSyntaxNodes for derived classes that store a location but not a SyntaxNode or SyntaxReference. Helper for implementing DeclaringSyntaxNodes for derived classes that store SyntaxReferences. Get this accessibility that was declared on this symbol. For symbols that do not have accessibility declared on them, returns NotApplicable. Returns true if this symbol is "shared"; i.e., declared with the "Shared" modifier or implicitly always shared. Returns true if this member is overridable, has an implementation, and does not override a base class member; i.e., declared with the "Overridable" modifier. Does not return true for members declared as MustOverride or Overrides. Returns true if this symbol was declared to override a base class members; i.e., declared with the "Overrides" modifier. Still returns true if the members was declared to override something, but (erroneously) no member to override exists. Returns true if this symbol was declared as requiring an override; i.e., declared with the "MustOverride" modifier. Never returns true for types. Also methods, properties and events declared in interface are considered to have MustOverride. Returns true if this symbol was declared to override a base class members and was also restricted from further overriding; i.e., declared with the "NotOverridable" modifier. Never returns true for types. Returns true if this symbol was automatically created by the compiler, and does not have an explicit corresponding source code declaration. This is intended for symbols that are ordinary symbols in the language sense, and may be used by code, but that are simply declared implicitly rather than with explicit language syntax. Examples include (this list is not exhaustive): the default constructor for a class or struct that is created if one is not provided, the BeginInvoke/Invoke/EndInvoke methods for a delegate, the generated backing field for an auto property or a field-like event, the "this" parameter for non-static methods, the "value" parameter for a property setter, the parameters on indexer accessor methods (not on the indexer itself), methods in anonymous types True if this symbol has been marked with the Obsolete attribute. This property returns Unknown if the Obsolete Attribute hasn't been cracked yet. True if this symbol has been marked with the Experimental attribute. This property returns Unknown if the Experimental attribute hasn't been cracked yet. Returns data decoded from Obsolete/Experimental attribute or null if there is no Obsolete/Experimental attribute. This property returns ObsoleteAttributeData.Uninitialized if attribute arguments haven't been decoded yet. Returns the symbol that implicitly defined this symbol, or Nothing if this symbol was declared explicitly. Examples of implicit symbols are property accessors and the backing field for an automatically implemented property. NOTE: there are scenarios in which ImplicitlyDefinedBy is called while bound members are not yet published. This typically happens if ImplicitlyDefinedBy while binding members. In such case, if callee needs to refer to a member of enclosing type it must do that in the context of unpublished members that caller provides (asking encompassing type for members will cause infinite recursion). NOTE: There could be several threads trying to bind and publish members, only one will succeed. Reporting ImplicitlyDefinedBy within the set of members known to the caller guarantees that if particular thread succeeds it will not have information that refers to something built by another thread and discarded. Returns true if 'Shadows' is explicitly specified on the declaration if the symbol is from source, or in cases of synthesized symbols, if 'Shadows' is specified on the associated source symbol. (For instance, ShadowsExplicitly will be set on the backing fields and accessors for properties and events based on the value from the property or event.) Returns false in all other cases, in particular, for symbols not from source. Returns true if this symbol can be referenced by its name in code. Examples of symbols that cannot be referenced by name are: constructors, operators, accessor methods for properties and events. As an optimization, viability checking in the lookup code should use this property instead of CanBeReferencedByName. This property exists purely for performance reasons. Is this a symbol that is generated by the compiler and automatically added to the compilation? Note that only source symbols may be embedded symbols. Namespace symbol is considered to be an embedded symbol if at least one of its declarations are embedded symbols. effective for this symbol (type or DllImport method). Nothing if isn't applied on the containing module or it doesn't apply on this symbol. Determined based upon value specified via applied on the containing module. Symbols that are embedded are not affected by (see DevDiv bug #16434). Always prefer IsFromCompilation. This property is actually a triple workaround: 1) Unfortunately, when determining overriding/hiding/implementation relationships, we don't have the "current" compilation available. We could, but that would clutter up the API without providing much benefit. As a compromise, we consider all compilations "current". 2) TypeSymbol.Interfaces doesn't roundtrip in the presence of implicit interface implementation. In particular, the metadata symbol may declare fewer interfaces than the source symbol so that runtime implicit interface implementation will find the right symbol. Thus, we need to know what kind of symbol we are dealing with to be able to interpret the Interfaces property properly. Since a retargeting TypeSymbol will reflect the behavior of the underlying source TypeSymbol, we need this property to match as well. (C# does not have this problem.) 3) The Dev12 VB compiler avoided loading private fields of structs from metadata, even though they're supposed to affect definite assignment analysis. For compatibility we therefore ignore these fields when doing DA analysis. (C# has a similar issue.) Equivalent to MethodKind = MethodKind.LambdaMethod, but can be called on a symbol directly. Is this an auto-generated property of a group class? Is this lambda method a query lambda? If it is, IsLambdaMethod == True as well. Returns the Documentation Comment ID for the symbol, or Nothing if the symbol doesn't support documentation comments. Fetches the documentation comment for this element with a cancellation token. Optionally, retrieve the comments formatted for a particular culture. No impact on source documentation comments. Optionally, expand ]]> elements. No impact on non-source documentation comments. Optionally, allow cancellation of documentation comment retrieval. The XML that would be written to the documentation file for the symbol. Compare two symbol objects to see if they refer to the same symbol. You should always use = and <> or the Equals method, to compare two symbols for equality. Compare two symbol objects to see if they refer to the same symbol. You should always use = and <>, or the Equals method, to compare two symbols for equality. Force all declaration diagnostics to be generated for the symbol. Returns dependencies and an error info for an error, if any, that should be reported at the use site of the symbol. Indicates that this symbol uses metadata that cannot be supported by the language. Examples include: - Pointer types in VB - ByRef return type - Required custom modifiers This is distinguished from, for example, references to metadata symbols defined in assemblies that weren't referenced. Symbols where this returns true can never be used successfully, and thus should never appear in any IDE feature. This is set for metadata symbols, as follows: Type - if a type is unsupported (e.g., a pointer type, etc.) Method - parameter or return type is unsupported Field - type is unsupported Event - type is unsupported Property - type is unsupported Parameter - type is unsupported Derive dependencies and error info from a type symbol. Returns true if the error code is highest priority while calculating use site error for this symbol. Gets the attributes on this symbol. Returns an empty ImmutableArray if there are no attributes. Build and add synthesized attributes for this symbol. Convenience helper called by subclasses to add a synthesized attribute to a collection of attributes. Returns the appropriate AttributeTarget for a symbol. This is used to validate attribute usage when applying an attribute to a symbol. For any symbol that does not support the application of custom attributes 0 is returned. The attribute target flag for this symbol or 0 if none apply. Method to early decode applied well-known attribute which can be queried by the binder. This method is called during attribute binding after we have bound the attribute types for all attributes, but haven't yet bound the attribute arguments/attribute constructor. Early decoding certain well-known attributes enables the binder to use this decoded information on this symbol when binding the attribute arguments/attribute constructor without causing attribute binding cycle. This method is called by the binder when it is finished binding a set of attributes on the symbol so that the symbol can extract data from the attribute arguments and potentially perform validation specific to some well known attributes. Symbol types should override this if they want to handle a specific well-known attribute. If the attribute is of a type that the symbol does not wish to handle, it should delegate back to this (base) method. Called to report attribute related diagnostics after all attributes have been bound and decoded. Called even if there are no attributes. This method is called by the binder from after it has finished binding attributes on the symbol, has executed for attributes applied on the symbol and has stored the decoded data in the lazyCustomAttributesBag on the symbol. Bound attributes haven't been stored on the bag yet. Post-validation for attributes that is dependent on other attributes can be done here. This method should not have any side effects on the symbol, i.e. it SHOULD NOT change the symbol state. Bound attributes. Syntax nodes of attributes in order they are specified in source. Diagnostic bag. Specific part of the symbol to which the attributes apply, or if the attributes apply to the symbol itself. Decoded well known attribute data. This method does the following set of operations in the specified order: (1) GetAttributesToBind: Merge the given attributeBlockSyntaxList into a single list of attributes to bind. (2) GetAttributes: Bind the attributes (attribute type, arguments and constructor). (3) DecodeWellKnownAttributes: Decode and validate bound well-known attributes. (4) ValidateAttributes: Perform some additional attribute validations, such as 1) Duplicate attributes, 2) Attribute usage target validation, etc. (5) Store the bound attributes and decoded well-known attribute data in lazyCustomAttributesBag in a thread safe manner. Method to early decode certain well-known attributes which can be queried by the binder. This method is called during attribute binding after we have bound the attribute types for all attributes, but haven't yet bound the attribute arguments/attribute constructor. Early decoding certain well-known attributes enables the binder to use this decoded information on this symbol when binding the attribute arguments/attribute constructor without causing attribute binding cycle. This method validates attribute usage for each bound attribute and calls on attributes with valid attribute usage. This method is called by the binder when it is finished binding a set of attributes on the symbol so that the symbol can extract data from the attribute arguments and potentially perform validation specific to some well known attributes. Validate attribute usage target and duplicate attributes. Bound attribute Syntax node for attribute specification Compilation Symbol part to which the attribute has been applied Diagnostics Set of unique attribute types applied to the symbol Ensure that attributes are bound and the ObsoleteState/ExperimentalState of this symbol is known. This diagnostic indicates when a symbol is not good for binding against. Client code can obtain the bad symbol via the BadSymbol property. This diagnostics indicates when a lookup is ambiguous between multiple equally good symbols, for example in different imported namespaces, or different modules. Client code can obtain the set of ambiguous symbols via the AmbiguousSymbols property. Add a diagnostic to the bag. Add a diagnostic to the bag. Appends diagnostics from useSiteDiagnostics into diagnostics and returns True if there were any errors. The Diagnostic class allows formatting of Visual Basic diagnostics. Gets the current DiagnosticFormatter instance. Concatenates messages for a set of DiagnosticInfo. Returns true if this is a build-only diagnostic that is never reported from API. Diagnostics generated during compilation phases such as lowering, emit, etc. are example of build-only diagnostics. The LocalizableErrorArgument class contains members that allows formatting and serialization of error arguments. Message IDs may refer to strings that need to be localized. This struct makes an IFormattable wrapper around a MessageID Creates a string representing the unformatted LocalizableErrorArgument instance. Creates a string representing the formatted LocalizableErrorArgument instance. A string to use for formatting. An object that supplies culture-specific format information about format. The base class for all nodes in the VB syntax tree. Should only be called during construction. This should probably be an extra constructor parameter, but we don't need more constructor overloads. Get all syntax errors associated with this node, or any child nodes, grand-child nodes, etc. The errors are not in order. The base class for all nodes that represent statements. This includes both declaration statements, such as class declarations as well as executable statements. The base class for all nodes that represent executable statements. The base class for all nodes that represent statements that declare options, imports, members, etc. A class to represent an empty statement. This can occur when a colon is on a line without anything else. An empty token because all non terminals must have a token. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an entire source file of VB code. Represents the list of Option statements at the beginning of a source file. If nothing is present, an empty list is returned. Represents the list of Imports statements at the beginning of a source file. If nothing is present, an empty list is returned. Represents the list of AttributeStatements at the beginning of a source file that contain the Assembly and Module attributes. If nothing is present, an empty list is returned. Represents the members of the default namespace for this source file: all the top-level type and namespace declarations in the file. May also contain Statements that are not valid If nothing is present, an empty list is returned. Represents the end of the source file. This token may have trivia (whitespace, comments, ...) attached to it. Represents an Option statement, such as "Option Strict On". The "Option" keyword. The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. The keyword that identifiers the value being set for the option: On, Off, Text or Binary. This child is optional. If it is not present, then Nothing is returned. Represents an Imports statement, which has one or more imports clauses. The "Imports" keyword. A list of one or more import clauses. Each clause is either an alias, namespace or XML namespace import. If nothing is present, an empty list is returned. The base class for the possible clauses of an Imports statement. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. An optional alias for the namespace or type being imported. This child is optional. If it is not present, then Nothing is returned. The namespace or type being imported. Represents an alias identifier followed by an "=" token in an Imports clause. The identifier being introduced. The "=" token. Defines a XML namespace for XML expressions. Identifies the XML namespace alias and URI. Represents a Namespace statement, its contents and the End Namespace statement. The statement that begins the NamespaceBlock. The declarations contained in the namespace statement. If nothing is present, an empty list is returned. The End Namespace statement that ends the block. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. The "Namespace" keyword. A (possibly dotted) name denoting the namespace being declared. Represents a declaration of a Class, Interface, Structure, Module, its contents and the End statement that ends it. A list of the Inherits declarations for the type. If nothing is present, an empty list is returned. A list of the Implements declarations for the type. If nothing is present, an empty list is returned. The declarations contained in the type or module. If nothing is present, an empty list is returned. The statement that begins the block declaration. The statement that ends the block declaration. Represents a declaration of Module, its contents and the End statement that ends it. The "Module" statement that begins the block. The "End Module" statement that ends the block. Represents a declaration of a Structure, its contents and the End statement that ends it. The "Structure" statement that begins the block. The "End Structure" statement that ends the block. Represents a declaration of a Interface, its contents and the End statement that ends it. The "Interface" statement that begins the block. The "End Interface" statement that ends the block. Represents a declaration of a Class its contents and the End statement that ends it. The "Class" statement that begins the block. The "End Class" statement that ends the block. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. The statement that begins the type or module. The declarations contained in the enumeration. If nothing is present, an empty list is returned. The End XXX statement that ends the block. Represents an Inherits or Implements statement in a Class, Structure or Interface. Represents an Inherits statement in a Class, Structure or Interface. The "Inherits" keyword. A list of the types being inherited. Represents an Implements statement in a Class or Structure. The "Implements" keyword. A list of the types being implemented. Abstract class for the beginning statement of a Module, Class, Interface or Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock, ClassDeclarationBlock, InterfaceDeclarationBlock or StructureDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. The "Module" keyword. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. The "Structure" keyword. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. The "Interface" keyword. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. The "Class" keyword. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. The "Enum" keyword. The name of the enum being declared. Optional "As XXX" clause describing the underlying type of the enumeration. If no As clause was specified, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents the type parameter list in a declaration. The "(" token. The "Of" keyword. A list of the type parameters. There must be at least one type parameter in the list. The ")" token. Represents a type parameter on a generic type declaration. Represents the "In" or "Out" variance keyword on a type parameter, if present. If no variance modifier was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. The name of the type parameter The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. An abstract node class that is the parent of classes that describe type parameter constraint clauses. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. A list of the supplied constraints. If no constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". The "As" keyword. The "{" token. A list of the supplied constraints. If no constraints were supplied, an empty list is returned. The "}" token. An abstract node class that is the parent of classes that describe type parameter constraints. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. Represents a type parameter constraint that is a type. The type describing the constraint. Represents a name and value in an EnumDeclarationBlock. If nothing is present, an empty list is returned. An optional value for the enum member. This child is optional. If it is not present, then Nothing is returned. Represents a block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include methods, constructors, operators, property accessors and custom event accessors. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. The statement that begins the block declaration. The statement that ends the block declaration. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The "End Sub" or "End Function" statement that ends the block. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub New" statement that begins the block. The "End Sub" statement that ends the block declaration. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Operator" statement that begins the block. The "End Operator" statement that ends the block declaration. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. The property declaration that begins the block. The accessor blocks contained in the property, between the Property and the End Property statements. The End Property statement that ends the block. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. The event declaration that begins the block. The accessor blocks contained in the custom event declaration, between the Event statement and the End Event statement. The End Event statement that ends the block. An abstract node class that is the parent for declarations that are "method-like"; i.e., that have a parameter list and return type. This includes methods, constructors, properties, events, operators, declares, delegates, property accessors and custom event accessors. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents the parameter list in a method declaration. The "(" token that introduces the parameter list. If no parameter list was present, Nothing is returned. The list of parameters. If no parameter list was present, Nothing is returned. If nothing is present, an empty list is returned. The ")" token that concludes the parameter list. If no parameter list was present, Nothing is returned. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. If present, a Handles clause indicated the events that this method handles. This child is optional. If it is not present, then Nothing is returned. If present, an Implements clause indicated the interface methods that this method implements. This child is optional. If it is not present, then Nothing is returned. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The "Sub" keyword. The "New" keyword in the constructor declaration. A Declare statement that declares an external DLL method. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. This child is optional. If it is not present, then Nothing is returned. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. This child is optional. If it is not present, then Nothing is returned. The string literal with the alias. If not present, returns Nothing. This child is optional. If it is not present, then Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. A statement that declares a delegate type. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. The optional Custom keyword for custom event declarations. This child is optional. If it is not present, then Nothing is returned. The "Event" keyword that introduces this event declaration. The name of the event being declared. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. If present, an Implements clause indicates the interface methods that this method implements. This child is optional. If it is not present, then Nothing is returned. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The "Operator" keyword that introduces this operator declaration. The operator being defined. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. The "Property" keyword that introduces this property declaration. The name of the property being declared. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. If present, an "= initial-value" clause describing the initial value of the property. This child is optional. If it is not present, then Nothing is returned. If present, an Implements clause indicated the interface methods that this method implements. This child is optional. If it is not present, then Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. The "Implements" keyword. The list of interface members being implemented. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. The "Handles" keyword. The list of event members being handled. Represents container of an event in a Handles clause item. Represents event container specified through special keywords "Me", "MyBase" or "MyClass".. The container of the event. This can be one of the special keywords: "Me", "MyBase" or "MyClass". Represents event container that refers to a WithEvents member. The container of the event. It is a simple identifier that refers to a WithEvents member of the containing type. Represents event container that refers to a WithEvents member's property. The container of the event. The "." token. The provider of the event. It is a property of a WithEvents member of the containing type. Represents a single handled event in a "Handles ..." clause. The container of the event. This can either be a simple identifier (identifying a members of the containing type) or one of the special keywords "Me", "MyBase" or "MyClass". The "." token. The event being handled. This must be a simple identifier. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. The missing identifier token for this incomplete member. Should only be used to have a location for error reporting. This child is optional. If it is not present, then Nothing is returned. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. The "As" clause that describes the return type, and possibly includes "New", "With" or "From". If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. If present, an "= initial-value" clause describing the initial value of the variable or the value of the constant. This child is optional. If it is not present, then Nothing is returned. Abstract node class that represents the different kinds of "As {type-name}" clauses in a declaration: simple "As" clauses and "As New" clauses. The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. The "As" keyword. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. The type-name part of the As clause. Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) The New expression An abstract node class that represents a "With" or "From" clause used to initialize a new object. Represents a "With {...} clause used to initialize a new object's members. The "With" keyword. The "{" token. The comma-separated list of field initializers. The "}" token. Represents a "From {...} clause used to initialize a new collection object's elements. The "From" keyword. The initializer including the braces. Abstract class that represent a single field initializer used in a "With {...}" field initializer list. The optional "Key" keyword. This child is optional. If it is not present, then Nothing is returned. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. The value being assigned. Represent a named field initializer in a With {...} initializer, such as ".x = expr". The "." token. The name of the field being initialized. The "=" token. The value being assigned to the field. Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. The "=" token. The expression used as the initial value. Represent a parameter to a method, property, constructor, etc. A list of all attribute lists on this parameter. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. A list of the modifier tokens "ByVal", "ByRef", "Optional" or "ParamArray" that modify this parameter. If nothing is present, an empty list is returned. The name of the parameter, including any "?" or "()" modifiers. If present, the "As type-name" clause describing the type of the parameter. If no As clause is present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. If present, an initializer with the default value of the parameter. If no default value is present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. The "?" token that indicates a nullable type. This child is optional. If it is not present, then Nothing is returned. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". This child is optional. If it is not present, then Nothing is returned. A list of array modifiers for the type. If no array modifiers were present, an empty list is returned. If nothing is present, an empty list is returned. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". The "(" token. The comma tokens in the array type. There is one less comma than the rank. If nothing is present, an empty list is returned. The ")" token. Represents a group of attributes within "<" and ">" brackets. The "<" token. A comma separated list of attribute declarations in this attribute list. If nothing is present, an empty list is returned. The ">" token. Represents a single attribute declaration within an attribute list. Optional attribute target. Assembly|Module : This child is optional. If it is not present, then Nothing is returned. The name of the attribute. The argument list, if present. If no argument list was supplied, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents a single attribute declaration within an attribute list. The "Assembly" or "Module" attribute modifier, is present. If no attribute modifier is present, Nothing is returned. The ":" token, if an attribute modifier is present. If no attribute modifier is present, Nothing is returned. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. The list of attribute lists. If nothing is present, an empty list is returned. Represent an expression in a statement context. This may only be a invocation or await expression in standard code but may be any expression in VB Interactive code. The expression. Represent a "? expression" "Print" statement in VB Interactive code. "?" token. The expression whose value is being output. Represents a While...End While statement, including the While, body and End While. The While statement that begins the block. The statements contained in the While...End While. This might be an empty list. If nothing is present, an empty list is returned. The End While statement that ends the block. Represents an entire Using...End Using statement, including the Using, body and End Using statements. The UsingStatement that begins the Using...End Using block. The statements contained in the Using...End Using block. This might be an empty list. If nothing is present, an empty list is returned. The End Using statement that ends the block. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. The SyncLock statement that begins the block. The statements contained in the SyncLock...End SyncLock statement. This might be an empty list. If nothing is present, an empty list is returned. The End SyncLock statement that ends the block. Represents a With...End With block, include the With statement, the body of the block and the End With statement. The WithStatement that begins the With...End With block. The statements contained in the With...End With block. This might be an empty list. If nothing is present, an empty list is returned. The End With statement that ends the block. Represents the declaration of one or more local variables or constants. The modifier token (Static, Dim or Const) that introduces this local variable declaration. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents a label statement. The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. The ":" token of the label statement. Represents a "GoTo" statement. The "GoTo" keyword. The name of the label. If the label is a line number, wraps an IntegerLiteral that is the line number, otherwise, wraps an Identifier. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Return" statement. The "Return" keyword. The expression being returned, if present. This child is optional. If it is not present, then Nothing is returned. Represents a single-line "If ... Then ... Else ..." statement. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. A list of statements to be executed if the condition expression evaluates as true. Multiple statements must be separated by colons. If nothing is present, an empty list is returned. An "Else" clause to be executed if the condition expression evaluates as false. This child is optional. If it is not present, then Nothing is returned. Represents the "Else ..." clause of a single-line "If" statement. The "Else" keyword. A list of statements to be executed. Multiple statements must be separated by colons. If nothing is present, an empty list is returned. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. The "If" statement that begins the "If" block. A list of statements to be executed if the condition expression evaluates as true. If nothing is present, an empty list is returned. A list of "ElseIf" blocks to be evaluated, in order, if the condition expression of the "If" statement evaluates as false. If nothing is present, an empty list is returned. An "Else" block to be executed if the condition expression of the "If" statement and all "ElseIf" blocks evaluate as false. This child is optional. If it is not present, then Nothing is returned. Then "End If" statement. Represents the "If ... Then" statement that begins a multi-line "If" block. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. This child is optional. If it is not present, then Nothing is returned. Represents an "ElseIf ... Then ..." block. The "ElseIf ... Then" statement the begins the "ElseIf" block. A list of statements to be executed if the condition expression of the "ElseIf" statement evaluates as true. If nothing is present, an empty list is returned. Represents the "ElseIf ... Then" statement that begins an "ElseIf" block. The "ElseIf" keyword. The condition expression to be evaluated. The "Then" keyword. This child is optional. If it is not present, then Nothing is returned. Represents an "Else ..." block. The "Else" statement that begins the "Else" block. A list of statements to be executed. If nothing is present, an empty list is returned. Represents the "Else" statement that begins an "Else" block. The "Else" keyword. Represents a "Try ... Catch ... Finally ... End Try" block. The "Try" statement that begins the "Try" block. A list of statements to be executed. If nothing is present, an empty list is returned. A list of "Catch" blocks which may be executed if an exception is thrown while executing the statements in the "Try" block. If nothing is present, an empty list is returned. A "Finally" block to be executed before execution leaves the "Try" block. This child is optional. If it is not present, then Nothing is returned. The "End Try" statement. Represents the "Try" statement that begins a "Try" block. The "Try" keyword. Represents a "Catch ..." block. The "Catch" statement that begins the "Catch" block. A list of statements to be executed if an exception is caught by the "Catch" block. If nothing is present, an empty list is returned. Represents the "Catch ... When ..." statement that begins a "Catch" block. The "Catch" keyword. An identifier declaring a new variable or naming an existing variable to store the exception caught by the "Catch" statement. This child is optional. If it is not present, then Nothing is returned. A simple "As" clause specifying the type of exception to catch. This child is optional. If it is not present, then Nothing is returned. A "When" clause to filter exceptions before catching. This child is optional. If it is not present, then Nothing is returned. Represents the "When ..." clause of a "Catch" statement. The "When" keyword. The filter expression to be evaluated. Represents a "Finally ..." block of a "Try" block. The "Finally" statement that begins the "Finally" block. A list of statements to be executed. If nothing is present, an empty list is returned. Represents the "Finally" statement that begins a "Finally" block. The "Finally" keyword. Represents the "Error" statement. The "Error" keyword. The expression that represents the error number. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 This child is optional. If it is not present, then Nothing is returned. The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Resume Next statement. The "On" keyword The "Error" keyword. The "Resume" keyword. The "Next" Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. This child is optional. If it is not present, then Nothing is returned. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. The Select Case statement that begins the block. A list of the contained Case blocks. If nothing is present, an empty list is returned. The End Select statement that ends the block. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. The "Select" keyword. The "Case" keyword, if present. This child is optional. If it is not present, then Nothing is returned. The value that branching is based on. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. If nothing is present, an empty list is returned. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a single clause in a case statement. An abstract node that is the parent of different kinds of Case clauses. The "Else" part in a Case Else statement. The "Else" keyword. Represents a single value in a Case. The expression that denotes the value being tested against. Represents a range "expression To expression" in a Case. The lower bound of the range. The "To" keyword The upper bound of the range. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. This child is optional. If it is not present, then Nothing is returned. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. The "SyncLock" keyword. The expression being synchronized on. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. The Loop statement that ends the block. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. This child is optional. If it is not present, then Nothing is returned. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. This child is optional. If it is not present, then Nothing is returned. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. The While statement that begins a While...End While block. This statement always occurs as the Begin of a WhileBlock. The "While" keyword. The boolean expression that controls the While loop. Represents a For or For Each block. The statements contained in the For or For Each loop. This might be an empty list. If nothing is present, an empty list is returned. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. This child is optional. If it is not present, then Nothing is returned. Represents a For block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For statement that begins the block. Represents a For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For Each statement that begins the block. Represents a For or For Each statement. The "For" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "=" token. The expression denoting the initial value of the iteration. The "To" keyword. The expression denoting the final value of the iteration. The optional Step clause. This child is optional. If it is not present, then Nothing is returned. The Step clause in a For Statement. The "Step" keyword. The expression denoting the step increment. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "Each" keyword. The "In" keyword. The expression denoting the collection to iterate over. The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The "Next" keyword. The variables in the Next statement, if present If nothing is present, an empty list is returned. The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. The "Using" keyword. If the Using statement is of a form that does not declare a new variable, this is the expression used in the using. Otherwise, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. If the Using statement is of a form that declares one or more new variables, this is the list of variable declarations. Otherwise, Nothing is returned. If nothing is present, an empty list is returned. Represents a Throw statement. The "Throw" keyword The expression denoting the value being thrown. This child is optional. If it is not present, then Nothing is returned. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a left-hand side of a MidAssignment statement. The "Mid" possibly followed by a type character. The argument list. Represent a call statement (also known as a invocation statement). The "Call" keyword. The expression denoting the call. This could be an Invocation or a MemberAccess (in the case where no parentheses were supplied.) Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represent a RaiseEvent statement. The "RaiseEvent" keyword The name of the event being raised. The argument list, if present. This child is optional. If it is not present, then Nothing is returned. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. The "With" keyword. The expression that is the operand of the With statement. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. This child is optional. If it is not present, then Nothing is returned. The list of ReDim clauses. Represents a ReDim statement clause. The target of the ReDim statement. The ArraySizeInitializationModifier. Represents an "Erase" statement. The "Erase" keyword. A list of expressions denoting the arrays to erase. An abstract base class for all node classes that define expressions. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a parenthesized expression. The "(" token The expression inside the parentheses. The ")" token Represents a tuple literal expression. The "(" token The list of tuple arguments. The ")" token Represents a tuple type expression. The "(" token The list of tuple elements. The ")" token Represents a single declaration of a tuple element. Represents a single declaration of a tuple element supplying only the type. The type-name part of the tuple element syntax. Represents a single declaration of a tuple element supplying element name and optionally a type. The name of the element. A simple "As" clause specifying the type of the tuple element. This child is optional. If it is not present, then Nothing is returned. Identifies one of the special instances "Me", "MyClass" or "MyBase". The Kind property identifies which. The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "Me" Identifies the special instance "MyBase" Identifies the special instance "MyClass" Represents a GetType expression. The "GetType" keyword. The "(" token. The type to get the Type object for. This can be an open generic type. The ")" token. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a GetXmlNamespace expression. The "GetXmlNamespace" keyword. The "(" token. The Xml namespace name being referenced. This child is optional. If it is not present, then Nothing is returned. The ")" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. This child is optional. If it is not present, then Nothing is returned. The "." or "!" token. The identifier after the "." or "!" token. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . This child is optional. If it is not present, then Nothing is returned. The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". This child is optional. If it is not present, then Nothing is returned. The third "." in a "..." separator. This child is optional. If it is not present, then Nothing is returned. The identifier after the ".", ".@" or "..." Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. The target of the call or index expression. This child is optional. If it is not present, then Nothing is returned. The argument list. This child is optional. If it is not present, then Nothing is returned. Base class for object, array and anonymous object creation expressions The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. The type of the object being initialized. The argument list, if present. If no argument list was supplied, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. An optional From or With clause to initialize the new object. This child is optional. If it is not present, then Nothing is returned. Represents a New expression that create an object of anonymous type. The With clause to initialize the new object. Represents an expression that creates a new array. The element type of the array being created. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". This child is optional. If it is not present, then Nothing is returned. A list of array modifiers such as "()" or "(,)". If no array modifiers were present, an empty list is returned. If nothing is present, an empty list is returned. The initializer including the braces. Represents an expression that creates a new array without naming the element type. The "{" token. The list of initializers between the braces. If nothing is present, an empty list is returned. The "}" token. Represents a CType, DirectCast or TryCast conversion expression. The Kind property determines which kind of cast it is. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. The keyword that was used in the cast operation. The "(" token. The expression being cast. The ")" token. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a lambda expression, either single line or multi-line. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Represents a single line lambda expression. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a multi-line lambda expression. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. If nothing is present, an empty list is returned. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents the header part of a lambda expression The "Sub" or "Function" keyword that introduces this lambda expression. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents a parenthesized argument list. The "(" token. The list of arguments. This may be empty. Omitted argument are represented by an OmittedArgumentSyntax node. If nothing is present, an empty list is returned. The ")" token. Base class for the possible kinds of arguments that can appear in an argument list. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. An empty token because all non terminals must have a token. Represents an argument that is just an optional argument name and an expression. The optional name and ":=" prefix of a named argument. This child is optional. If it is not present, then Nothing is returned. The expression that is the argument. Represents an identifier name followed by a ":=" token in a named argument. The name used to identify the named argument. The ":=" token. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. The lower bound of the range. This is typically the integer constant zero. The "To" keyword. The upper bound of the range. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. A list of all the query operators in this query expression. This list always contains at least one operator. This is a base class for all query operators. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. The name of the range variable being defined. Describes the type of the variable being defined. This child is optional. If it is not present, then Nothing is returned. The "In" keyword. The expression that serves as the source of items for the range variable. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the expression. This child is optional. If it is not present, then Nothing is returned. The expression used to initialize the expression variable. Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the aggregation expression. This child is optional. If it is not present, then Nothing is returned. The name of the aggregation function. The "Group" aggregation function is represented by the identifier "Group". Represents the name and optional type of an expression range variable. The name of the variable being defined. Describes the type of the variable being defined. This child is optional. If it is not present, then Nothing is returned. The "=" token. Represents aggregation in aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. The "(" token if present. This child is optional. If it is not present, then Nothing is returned. The argument to the aggregation function. This child is optional. If it is not present, then Nothing is returned. The ")" token, if present. This child is optional. If it is not present, then Nothing is returned. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. The "Group" keyword. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. The "From" keyword. The list of collection variables declared by this From operator. Represents a "Let" query operator. The "Let" keyword. The list of expression range variable being defined by the Let operator. Represents an Aggregate query operator. The "Aggregate" keyword. The list of collection range variables declared by this Aggregate operator. A list of additional query operators. It may be empty. If nothing is present, an empty list is returned. The "Into" keyword. The list of new variables being defined by the aggregation. Represents the "Distinct" query operator. The "Distinct" keyword. Represents a "Where" query operator. The "Where" keyword. The boolean expression used for filtering. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents the "Group By" query operator. The "Group" keyword. The optional list of variables being grouped; the contents of the Group clause. If none were specified, an empty list is returned. If nothing is present, an empty list is returned. The "By" keyword. The key values being used for grouping. The list of new variables that calculate aggregations. Represents a Join or a Group Join query operator. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. If nothing is present, an empty list is returned. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Represents the "expression Equals expression" condition in a Join. The left expression in the Join condition. The "Equals" keyword. The right expression in the Join condition. Represents a Join query operator. Represents the "Group Join" query operator. The "Group" keyword. The "Into" keyword. The list of new variables that calculate aggregations. Represents the "Order By" query operator. The "Order" keyword The "By" keyword. The list of OrderExpression's to sort by. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. This child is optional. If it is not present, then Nothing is returned. Represents the "Select" query operator. The "Select" keyword. The list of expression range variables being defined by the Select query operator. This is the base class for all XML expression syntax nodes (XmlDocument and XmlElement). Represents an XML Document literal expression. If nothing is present, an empty list is returned. If nothing is present, an empty list is returned. Represents the XML declaration prologue in an XML literal expression. This child is optional. If it is not present, then Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. Represents an XML element with content in an XML literal expression. If nothing is present, an empty list is returned. Represents Xml text. A list of all the text tokens in the Xml text. This list always contains at least one token. Represents the start tag of an XML element of the form <element>. If nothing is present, an empty list is returned. Represents the end tag of an XML element of the form </element>. This child is optional. If it is not present, then Nothing is returned. Represents an empty XML element of the form <element /> If nothing is present, an empty list is returned. Represents an XML attribute in an XML literal expression. Represents an XML attribute in an XML literal expression. Represents a string of XML characters embedded as the content of an XML element. If nothing is present, an empty list is returned. Represents an XML name of the form 'name' appearing in GetXmlNamespace(). Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. This child is optional. If it is not present, then Nothing is returned. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. Represents an XML CDATA section in an XML literal expression. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. Abstract node class that represents the textual description of a type, possibly include generic type arguments, qualified names, array specifiers, nullable specifier and the like. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. The type of the elements of the array. Represents the list of "()" or "(,,)" modifiers on the array type. A type name that represents a nullable type, such as "Integer?". The kind of type that is this type is a nullable of. Cannot be an array type or a nullable type. The "?" token. Represents an occurrence of a Visual Basic built-in type such as Integer or String in source code. The keyword that was used to describe the built-in type. Abstract node class that represents a name, possibly include generic arguments and qualified names. Abstract node class that represents a name, possibly include generic arguments. The identifier in the name. Represents a type name consisting of a single identifier (which might include brackets or a type character). Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). The generic argument list. Represents a qualified type name, for example X.Y or X(Of Z).Y. The part of the name that appears to the left of the dot. This can itself be any name. The "." token that separates the names. The part of the name that appears to the right of the dot. This must be a simple identifier. Represents a name in the global namespace. The "Global" keyword. Represents a parenthesized list of generic type arguments. The "(" token. The "Of" keyword. A list of all the type arguments. The ")" token. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. This child is optional. If it is not present, then Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. This child is optional. If it is not present, then Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represent a Yield statement. The "Yield" keyword. The expression whose value is being yielded. Represents an Await expression. The "Await" keyword. The expression being awaited. Represents a single syntactic token in a VB program. A token is a keyword, punctuator, literal, identifier or XML token. The type of keyword or punctuator can be determined from the Kind property. Helper to check whether the token is a keyword Helpers to check whether the token is a binary operator True if it is a binary operator Check whether the token is a statement terminator True if it is statement terminator Check whether token is end of text Create a new token with the trivia prepended to the existing preceding trivia Create a new token with the trivia appended to the existing following trivia Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents an Xml NCName per Namespaces in XML 1.0 Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The text of the attribute or pcdata after normalization. Represents literal character data in interpolated string expression. The text. Represents a Decimal literal token. The type suffix or type character that was on the literal, if any. If no suffix was present, TypeCharacter.None is returned. The value of the token. Represents a Date literal token. The value of the token. Represents a string literal token. The value of the string, after removing the quotation marks and combining doubled quotation marks. Represents a string literal token. The value of the character, after removing the quotation marks. Abstract class that represent structured trivia. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. The list of tokens that were skipped by the parser. If nothing is present, an empty list is returned. Represents a documentation comment e.g. ''' <Summary> appearing in source. If nothing is present, an empty list is returned. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. ExpressionSyntax node representing the object conditionally accessed. The expression on the left-hand-side of the "?". This child is optional. If it is not present, then Nothing is returned. "?" token. ExpressionSyntax node representing the access expression to be executed when the object is not null." Represents a NameOf expression. The "NameOf" keyword. The "(" token. The argument. The ")" token. Represents an interpolated string expression. The opening '$"', '$“', or '$”' token. The contents of the interpolated string. The closing '"', '”', or '“' token. Represents either text content or an interpolation. Represents literal text content in an interpolated string. The text token. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. The opening curly brace '{' token. The expression whose formatted value should be embedded in the resultant string. Optional. The alignment clause ',alignment' of the embedded expression. This child is optional. If it is not present, then Nothing is returned. Optional. The format string clause ':formatString' of the embedded expression. This child is optional. If it is not present, then Nothing is returned. The closing curly brace '}' token of the embedded expression. Represents an alignment clause ',alignment' of an interpolated string embedded expression. The comma ',' token. An expression representing the alignment of the interpolated expression. Represents a format string clause ':formatString' of an interpolated string embedded expression. The ':' token. The format string. Represents a pre-processing directive (such as #If, #Const or #Region) appearing in source. The "#" token in a preprocessor directive. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. Represents a #Const pre-processing constant declaration appearing in source. The "Const" keyword. The name of the pre-processing constant being defined. The "=" token. An expression representing the value of the pre-processing constant being defined. Represents the beginning of an #If pre-processing directive appearing in source. This child is optional. If it is not present, then Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Represents an #Else pre-processing directive appearing in source. Represents an #End If pre-processing directive appearing in source. Represents the beginning of a #Region directive appearing in source. The "Region" keyword. The label of the code region being defined. Represents an #End Region directive appearing in source. The "End" keyword. The "Region" keyword. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. Represents an #End ExternalSource pre-processing directive appearing in source. Represents an #ExternalChecksum pre-processing directive appearing in source. Represents #Enable Warning pre-processing directive appearing in source. Represents #Disable Warning pre-processing directive appearing in source. Represents an #r directive appearing in scripts. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. A class to represent an empty statement. This can occur when a colon is on a line without anything else. An empty token because all non terminals must have a token. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. A representing the specific kind of EndBlockStatementSyntax. One of EndIfStatement, EndUsingStatement, EndWithStatement, EndSelectStatement, EndStructureStatement, EndEnumStatement, EndInterfaceStatement, EndClassStatement, EndModuleStatement, EndNamespaceStatement, EndSubStatement, EndFunctionStatement, EndGetStatement, EndSetStatement, EndPropertyStatement, EndOperatorStatement, EndEventStatement, EndAddHandlerStatement, EndRemoveHandlerStatement, EndRaiseEventStatement, EndWhileStatement, EndTryStatement, EndSyncLockStatement. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an entire source file of VB code. Represents the list of Option statements at the beginning of a source file. Represents the list of Imports statements at the beginning of a source file. Represents the list of AttributeStatements at the beginning of a source file that contain the Assembly and Module attributes. Represents the members of the default namespace for this source file: all the top-level type and namespace declarations in the file. May also contain Statements that are not valid Represents the end of the source file. This token may have trivia (whitespace, comments, ...) attached to it. Represents an Option statement, such as "Option Strict On". The "Option" keyword. The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. The keyword that identifiers the value being set for the option: On, Off, Text or Binary. Represents an Imports statement, which has one or more imports clauses. The "Imports" keyword. A list of one or more import clauses. Each clause is either an alias, namespace or XML namespace import. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. An optional alias for the namespace or type being imported. The namespace or type being imported. Represents an alias identifier followed by an "=" token in an Imports clause. The identifier being introduced. The "=" token. Defines a XML namespace for XML expressions. Identifies the XML namespace alias and URI. Represents a Namespace statement, its contents and the End Namespace statement. The statement that begins the NamespaceBlock. The declarations contained in the namespace statement. The End Namespace statement that ends the block. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. The "Namespace" keyword. A (possibly dotted) name denoting the namespace being declared. Represents a declaration of Module, its contents and the End statement that ends it. The "Module" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Module" statement that ends the block. Represents a declaration of a Structure, its contents and the End statement that ends it. The "Structure" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Structure" statement that ends the block. Represents a declaration of a Interface, its contents and the End statement that ends it. The "Interface" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Interface" statement that ends the block. Represents a declaration of a Class its contents and the End statement that ends it. The "Class" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Class" statement that ends the block. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. The statement that begins the type or module. The declarations contained in the enumeration. The End XXX statement that ends the block. Represents an Inherits statement in a Class, Structure or Interface. The "Inherits" keyword. A list of the types being inherited. Represents an Implements statement in a Class or Structure. The "Implements" keyword. A list of the types being implemented. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Module" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Structure" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Interface" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Class" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Enum" keyword. The name of the enum being declared. Optional "As XXX" clause describing the underlying type of the enumeration. If no As clause was specified, Nothing is returned. Represents the type parameter list in a declaration. The "(" token. The "Of" keyword. A list of the type parameters. There must be at least one type parameter in the list. The ")" token. Represents a type parameter on a generic type declaration. Represents the "In" or "Out" variance keyword on a type parameter, if present. If no variance modifier was present, Nothing is returned. The name of the type parameter The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. A list of the supplied constraints. If no constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". The "As" keyword. The "{" token. A list of the supplied constraints. If no constraints were supplied, an empty list is returned. The "}" token. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. A representing the specific kind of SpecialConstraintSyntax. One of NewConstraint, ClassConstraint, StructureConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. Represents a type parameter constraint that is a type. The type describing the constraint. Represents a name and value in an EnumDeclarationBlock. An optional value for the enum member. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. A representing the specific kind of MethodBlockSyntax. One of SubBlock, FunctionBlock. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub New" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" statement that ends the block declaration. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Operator" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Operator" statement that ends the block declaration. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. A representing the specific kind of AccessorBlockSyntax. One of GetAccessorBlock, SetAccessorBlock, AddHandlerAccessorBlock, RemoveHandlerAccessorBlock, RaiseEventAccessorBlock. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. The property declaration that begins the block. The accessor blocks contained in the property, between the Property and the End Property statements. The End Property statement that ends the block. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. The event declaration that begins the block. The accessor blocks contained in the custom event declaration, between the Event statement and the End Event statement. The End Event statement that ends the block. Represents the parameter list in a method declaration. The "(" token that introduces the parameter list. If no parameter list was present, Nothing is returned. The list of parameters. If no parameter list was present, Nothing is returned. The ")" token that concludes the parameter list. If no parameter list was present, Nothing is returned. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A representing the specific kind of MethodStatementSyntax. One of SubStatement, FunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" keyword. The "New" keyword in the constructor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A representing the specific kind of DeclareStatementSyntax. One of DeclareSubStatement, DeclareFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A representing the specific kind of DelegateStatementSyntax. One of DelegateSubStatement, DelegateFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The optional Custom keyword for custom event declarations. The "Event" keyword that introduces this event declaration. The name of the event being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an Implements clause indicates the interface methods that this method implements. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Operator" keyword that introduces this operator declaration. The operator being defined. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Property" keyword that introduces this property declaration. The name of the property being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the property. If present, an Implements clause indicated the interface methods that this method implements. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A representing the specific kind of AccessorStatementSyntax. One of GetAccessorStatement, SetAccessorStatement, AddHandlerAccessorStatement, RemoveHandlerAccessorStatement, RaiseEventAccessorStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. The "Implements" keyword. The list of interface members being implemented. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. The "Handles" keyword. The list of event members being handled. Represents event container specified through special keywords "Me", "MyBase" or "MyClass".. The container of the event. This can be one of the special keywords: "Me", "MyBase" or "MyClass". Represents event container that refers to a WithEvents member. The container of the event. It is a simple identifier that refers to a WithEvents member of the containing type. Represents event container that refers to a WithEvents member's property. The container of the event. The "." token. The provider of the event. It is a property of a WithEvents member of the containing type. Represents a single handled event in a "Handles ..." clause. The container of the event. This can either be a simple identifier (identifying a members of the containing type) or one of the special keywords "Me", "MyBase" or "MyClass". The "." token. The event being handled. This must be a simple identifier. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The missing identifier token for this incomplete member. Should only be used to have a location for error reporting. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. The "As" clause that describes the return type, and possibly includes "New", "With" or "From". If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the variable or the value of the constant. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. The "As" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type-name part of the As clause. Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) The "As" keyword. The New expression Represents a "With {...} clause used to initialize a new object's members. The "With" keyword. The "{" token. The comma-separated list of field initializers. The "}" token. Represents a "From {...} clause used to initialize a new collection object's elements. The "From" keyword. The initializer including the braces. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. The optional "Key" keyword. The value being assigned. Represent a named field initializer in a With {...} initializer, such as ".x = expr". The optional "Key" keyword. The "." token. The name of the field being initialized. The "=" token. The value being assigned to the field. Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. The "=" token. The expression used as the initial value. Represent a parameter to a method, property, constructor, etc. A list of all attribute lists on this parameter. If no attributes were specified, Nothing is returned. A list of the modifier tokens "ByVal", "ByRef", "Optional" or "ParamArray" that modify this parameter. The name of the parameter, including any "?" or "()" modifiers. If present, the "As type-name" clause describing the type of the parameter. If no As clause is present, Nothing is returned. If present, an initializer with the default value of the parameter. If no default value is present, Nothing is returned. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. The "?" token that indicates a nullable type. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". A list of array modifiers for the type. If no array modifiers were present, an empty list is returned. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". The "(" token. The comma tokens in the array type. There is one less comma than the rank. The ")" token. Represents a group of attributes within "<" and ">" brackets. The "<" token. A comma separated list of attribute declarations in this attribute list. The ">" token. Represents a single attribute declaration within an attribute list. Optional attribute target. Assembly|Module : The name of the attribute. The argument list, if present. If no argument list was supplied, Nothing is returned. Represents a single attribute declaration within an attribute list. The "Assembly" or "Module" attribute modifier, is present. If no attribute modifier is present, Nothing is returned. The ":" token, if an attribute modifier is present. If no attribute modifier is present, Nothing is returned. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. The list of attribute lists. Represent an expression in a statement context. This may only be a invocation or await expression in standard code but may be any expression in VB Interactive code. The expression. Represent a "? expression" "Print" statement in VB Interactive code. "?" token. The expression whose value is being output. Represents a While...End While statement, including the While, body and End While. The While statement that begins the block. The statements contained in the While...End While. This might be an empty list. The End While statement that ends the block. Represents an entire Using...End Using statement, including the Using, body and End Using statements. The UsingStatement that begins the Using...End Using block. The statements contained in the Using...End Using block. This might be an empty list. The End Using statement that ends the block. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. The SyncLock statement that begins the block. The statements contained in the SyncLock...End SyncLock statement. This might be an empty list. The End SyncLock statement that ends the block. Represents a With...End With block, include the With statement, the body of the block and the End With statement. The WithStatement that begins the With...End With block. The statements contained in the With...End With block. This might be an empty list. The End With statement that ends the block. Represents the declaration of one or more local variables or constants. The modifier token (Static, Dim or Const) that introduces this local variable declaration. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents a label statement. The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. The ":" token of the label statement. Represents a "GoTo" statement. The "GoTo" keyword. The name of the label. If the label is a line number, wraps an IntegerLiteral that is the line number, otherwise, wraps an Identifier. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A representing the specific kind of LabelSyntax. One of IdentifierLabel, NumericLabel, NextLabel. The label name (identifier), line number (integer literal), or next keyword token. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. A representing the specific kind of StopOrEndStatementSyntax. One of StopStatement, EndStatement. The "Stop" or "End" keyword. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. A representing the specific kind of ExitStatementSyntax. One of ExitDoStatement, ExitForStatement, ExitSubStatement, ExitFunctionStatement, ExitOperatorStatement, ExitPropertyStatement, ExitTryStatement, ExitSelectStatement, ExitWhileStatement. The "Exit" keyword. The keyword describing the block to exit. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. A representing the specific kind of ContinueStatementSyntax. One of ContinueWhileStatement, ContinueDoStatement, ContinueForStatement. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Return" statement. The "Return" keyword. The expression being returned, if present. Represents a single-line "If ... Then ... Else ..." statement. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. A list of statements to be executed if the condition expression evaluates as true. Multiple statements must be separated by colons. An "Else" clause to be executed if the condition expression evaluates as false. Represents the "Else ..." clause of a single-line "If" statement. The "Else" keyword. A list of statements to be executed. Multiple statements must be separated by colons. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. The "If" statement that begins the "If" block. A list of statements to be executed if the condition expression evaluates as true. A list of "ElseIf" blocks to be evaluated, in order, if the condition expression of the "If" statement evaluates as false. An "Else" block to be executed if the condition expression of the "If" statement and all "ElseIf" blocks evaluate as false. Then "End If" statement. Represents the "If ... Then" statement that begins a multi-line "If" block. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. Represents an "ElseIf ... Then ..." block. The "ElseIf ... Then" statement the begins the "ElseIf" block. A list of statements to be executed if the condition expression of the "ElseIf" statement evaluates as true. Represents the "ElseIf ... Then" statement that begins an "ElseIf" block. The "ElseIf" keyword. The condition expression to be evaluated. The "Then" keyword. Represents an "Else ..." block. The "Else" statement that begins the "Else" block. A list of statements to be executed. Represents the "Else" statement that begins an "Else" block. The "Else" keyword. Represents a "Try ... Catch ... Finally ... End Try" block. The "Try" statement that begins the "Try" block. A list of statements to be executed. A list of "Catch" blocks which may be executed if an exception is thrown while executing the statements in the "Try" block. A "Finally" block to be executed before execution leaves the "Try" block. The "End Try" statement. Represents the "Try" statement that begins a "Try" block. The "Try" keyword. Represents a "Catch ..." block. The "Catch" statement that begins the "Catch" block. A list of statements to be executed if an exception is caught by the "Catch" block. Represents the "Catch ... When ..." statement that begins a "Catch" block. The "Catch" keyword. An identifier declaring a new variable or naming an existing variable to store the exception caught by the "Catch" statement. A simple "As" clause specifying the type of exception to catch. A "When" clause to filter exceptions before catching. Represents the "When ..." clause of a "Catch" statement. The "When" keyword. The filter expression to be evaluated. Represents a "Finally ..." block of a "Try" block. The "Finally" statement that begins the "Finally" block. A list of statements to be executed. Represents the "Finally" statement that begins a "Finally" block. The "Finally" keyword. Represents the "Error" statement. The "Error" keyword. The expression that represents the error number. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. A representing the specific kind of OnErrorGoToStatementSyntax. One of OnErrorGoToZeroStatement, OnErrorGoToMinusOneStatement, OnErrorGoToLabelStatement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Resume Next statement. The "On" keyword The "Error" keyword. The "Resume" keyword. The "Next" Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. The Select Case statement that begins the block. A list of the contained Case blocks. The End Select statement that ends the block. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. The "Select" keyword. The "Case" keyword, if present. The value that branching is based on. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. The "Else" part in a Case Else statement. The "Else" keyword. Represents a single value in a Case. The expression that denotes the value being tested against. Represents a range "expression To expression" in a Case. The lower bound of the range. The "To" keyword The upper bound of the range. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". A representing the specific kind of RelationalCaseClauseSyntax. One of CaseEqualsClause, CaseNotEqualsClause, CaseLessThanClause, CaseLessThanOrEqualClause, CaseGreaterThanOrEqualClause, CaseGreaterThanClause. The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. The "SyncLock" keyword. The expression being synchronized on. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. A representing the specific kind of DoLoopBlockSyntax. One of SimpleDoLoopBlock, DoWhileLoopBlock, DoUntilLoopBlock, DoLoopWhileBlock, DoLoopUntilBlock. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. A representing the specific kind of DoStatementSyntax. One of SimpleDoStatement, DoWhileStatement, DoUntilStatement. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. A representing the specific kind of LoopStatementSyntax. One of SimpleLoopStatement, LoopWhileStatement, LoopUntilStatement. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. A representing the specific kind of WhileOrUntilClauseSyntax. One of WhileClause, UntilClause. The "While" or "Until" keyword. The boolean expression after the While or Until. The While statement that begins a While...End While block. This statement always occurs as the Begin of a WhileBlock. The "While" keyword. The boolean expression that controls the While loop. Represents a For block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For statement that begins the block. The statements contained in the For or For Each loop. This might be an empty list. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. Represents a For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For Each statement that begins the block. The statements contained in the For or For Each loop. This might be an empty list. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "For" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The "=" token. The expression denoting the initial value of the iteration. The "To" keyword. The expression denoting the final value of the iteration. The optional Step clause. The Step clause in a For Statement. The "Step" keyword. The expression denoting the step increment. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "For" keyword. The "Each" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The "In" keyword. The expression denoting the collection to iterate over. The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The "Next" keyword. The variables in the Next statement, if present The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. The "Using" keyword. If the Using statement is of a form that does not declare a new variable, this is the expression used in the using. Otherwise, Nothing is returned. If the Using statement is of a form that declares one or more new variables, this is the list of variable declarations. Otherwise, Nothing is returned. Represents a Throw statement. The "Throw" keyword The expression denoting the value being thrown. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. A representing the specific kind of AssignmentStatementSyntax. One of SimpleAssignmentStatement, MidAssignmentStatement, AddAssignmentStatement, SubtractAssignmentStatement, MultiplyAssignmentStatement, DivideAssignmentStatement, IntegerDivideAssignmentStatement, ExponentiateAssignmentStatement, LeftShiftAssignmentStatement, RightShiftAssignmentStatement, ConcatenateAssignmentStatement. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a left-hand side of a MidAssignment statement. The "Mid" possibly followed by a type character. The argument list. Represent a call statement (also known as a invocation statement). The "Call" keyword. The expression denoting the call. This could be an Invocation or a MemberAccess (in the case where no parentheses were supplied.) Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. A representing the specific kind of AddRemoveHandlerStatementSyntax. One of AddHandlerStatement, RemoveHandlerStatement. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represent a RaiseEvent statement. The "RaiseEvent" keyword The name of the event being raised. The argument list, if present. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. The "With" keyword. The expression that is the operand of the With statement. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement clause. The target of the ReDim statement. The ArraySizeInitializationModifier. Represents an "Erase" statement. The "Erase" keyword. A list of expressions denoting the arrays to erase. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. A representing the specific kind of LiteralExpressionSyntax. One of CharacterLiteralExpression, TrueLiteralExpression, FalseLiteralExpression, NumericLiteralExpression, DateLiteralExpression, StringLiteralExpression, NothingLiteralExpression. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a parenthesized expression. The "(" token The expression inside the parentheses. The ")" token Represents a tuple literal expression. The "(" token The list of tuple arguments. The ")" token Represents a tuple type expression. The "(" token The list of tuple elements. The ")" token Represents a single declaration of a tuple element supplying only the type. The type-name part of the tuple element syntax. Represents a single declaration of a tuple element supplying element name and optionally a type. The name of the element. A simple "As" clause specifying the type of the tuple element. Identifies the special instance "Me" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "MyBase" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "MyClass" The "Me", "MyClass" or "MyBase" keyword. Represents a GetType expression. The "GetType" keyword. The "(" token. The type to get the Type object for. This can be an open generic type. The ")" token. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. A representing the specific kind of TypeOfExpressionSyntax. One of TypeOfIsExpression, TypeOfIsNotExpression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a GetXmlNamespace expression. The "GetXmlNamespace" keyword. The "(" token. The Xml namespace name being referenced. The ")" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. A representing the specific kind of MemberAccessExpressionSyntax. One of SimpleMemberAccessExpression, DictionaryAccessExpression. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. A representing the specific kind of XmlMemberAccessExpressionSyntax. One of XmlElementAccessExpression, XmlDescendantAccessExpression, XmlAttributeAccessExpression. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. The target of the call or index expression. The argument list. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type of the object being initialized. The argument list, if present. If no argument list was supplied, Nothing is returned. An optional From or With clause to initialize the new object. Represents a New expression that create an object of anonymous type. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The With clause to initialize the new object. Represents an expression that creates a new array. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The element type of the array being created. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". A list of array modifiers such as "()" or "(,)". If no array modifiers were present, an empty list is returned. The initializer including the braces. Represents an expression that creates a new array without naming the element type. The "{" token. The list of initializers between the braces. The "}" token. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. The keyword that was used in the cast operation. The "(" token. The expression being cast. The ")" token. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. A representing the specific kind of BinaryExpressionSyntax. One of AddExpression, SubtractExpression, MultiplyExpression, DivideExpression, IntegerDivideExpression, ExponentiateExpression, LeftShiftExpression, RightShiftExpression, ConcatenateExpression, ModuloExpression, EqualsExpression, NotEqualsExpression, LessThanExpression, LessThanOrEqualExpression, GreaterThanOrEqualExpression, GreaterThanExpression, IsExpression, IsNotExpression, LikeExpression, OrExpression, ExclusiveOrExpression, AndExpression, OrElseExpression, AndAlsoExpression. The left operand. The right operand. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. A representing the specific kind of UnaryExpressionSyntax. One of UnaryPlusExpression, UnaryMinusExpression, NotExpression, AddressOfExpression. The token that is the operator. The expression being operated on. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a single line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a single line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a single line lambda expression. A representing the specific kind of SingleLineLambdaExpressionSyntax. One of SingleLineFunctionLambdaExpression, SingleLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. A representing the specific kind of MultiLineLambdaExpressionSyntax. One of MultiLineFunctionLambdaExpression, MultiLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A representing the specific kind of LambdaHeaderSyntax. One of SubLambdaHeader, FunctionLambdaHeader. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents a parenthesized argument list. The "(" token. The list of arguments. This may be empty. Omitted argument are represented by an OmittedArgumentSyntax node. The ")" token. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. An empty token because all non terminals must have a token. Represents an argument that is just an optional argument name and an expression. The optional name and ":=" prefix of a named argument. The expression that is the argument. Represents an identifier name followed by a ":=" token in a named argument. The name used to identify the named argument. The ":=" token. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. The lower bound of the range. This is typically the integer constant zero. The "To" keyword. The upper bound of the range. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. A list of all the query operators in this query expression. This list always contains at least one operator. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. The name of the range variable being defined. Describes the type of the variable being defined. The "In" keyword. The expression that serves as the source of items for the range variable. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the expression. The expression used to initialize the expression variable. Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the aggregation expression. The name of the aggregation function. The "Group" aggregation function is represented by the identifier "Group". Represents the name and optional type of an expression range variable. The name of the variable being defined. Describes the type of the variable being defined. The "=" token. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. The "(" token if present. The argument to the aggregation function. The ")" token, if present. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. The "Group" keyword. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. The "From" keyword. The list of collection variables declared by this From operator. Represents a "Let" query operator. The "Let" keyword. The list of expression range variable being defined by the Let operator. Represents an Aggregate query operator. The "Aggregate" keyword. The list of collection range variables declared by this Aggregate operator. A list of additional query operators. It may be empty. The "Into" keyword. The list of new variables being defined by the aggregation. Represents the "Distinct" query operator. The "Distinct" keyword. Represents a "Where" query operator. The "Where" keyword. The boolean expression used for filtering. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. A representing the specific kind of PartitionWhileClauseSyntax. One of SkipWhileClause, TakeWhileClause. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. A representing the specific kind of PartitionClauseSyntax. One of SkipClause, TakeClause. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents the "Group By" query operator. The "Group" keyword. The optional list of variables being grouped; the contents of the Group clause. If none were specified, an empty list is returned. The "By" keyword. The key values being used for grouping. The list of new variables that calculate aggregations. Represents the "expression Equals expression" condition in a Join. The left expression in the Join condition. The "Equals" keyword. The right expression in the Join condition. Represents a Join query operator. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Represents the "Group Join" query operator. The "Group" keyword. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. The "Into" keyword. The list of new variables that calculate aggregations. Represents the "Order By" query operator. The "Order" keyword The "By" keyword. The list of OrderExpression's to sort by. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. A representing the specific kind of OrderingSyntax. One of AscendingOrdering, DescendingOrdering. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. Represents the "Select" query operator. The "Select" keyword. The list of expression range variables being defined by the Select query operator. Represents an XML Document literal expression. Represents the XML declaration prologue in an XML literal expression. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. Represents an XML element with content in an XML literal expression. Represents Xml text. A list of all the text tokens in the Xml text. This list always contains at least one token. Represents the start tag of an XML element of the form <element>. Represents the end tag of an XML element of the form </element>. Represents an empty XML element of the form <element /> Represents an XML attribute in an XML literal expression. Represents a string of XML characters embedded as the content of an XML element. Represents an XML name of the form 'name' appearing in GetXmlNamespace(). Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. Represents an XML CDATA section in an XML literal expression. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. The type of the elements of the array. Represents the list of "()" or "(,,)" modifiers on the array type. A type name that represents a nullable type, such as "Integer?". The kind of type that is this type is a nullable of. Cannot be an array type or a nullable type. The "?" token. Represents an occurrence of a Visual Basic built-in type such as Integer or String in source code. The keyword that was used to describe the built-in type. Represents a type name consisting of a single identifier (which might include brackets or a type character). The identifier in the name. Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). The identifier in the name. The generic argument list. Represents a qualified type name, for example X.Y or X(Of Z).Y. The part of the name that appears to the left of the dot. This can itself be any name. The "." token that separates the names. The part of the name that appears to the right of the dot. This must be a simple identifier. Represents a name in the global namespace. The "Global" keyword. Represents a parenthesized list of generic type arguments. The "(" token. The "Of" keyword. A list of all the type arguments. The ")" token. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. Represent a Yield statement. The "Yield" keyword. The expression whose value is being yielded. Represents an Await expression. The "Await" keyword. The expression being awaited. Represents an Xml NCName per Namespaces in XML 1.0 The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. A representing the specific kind of XmlTextTokenSyntax. One of XmlTextLiteralToken, XmlEntityLiteralToken, DocumentationCommentLineBreakToken. The actual text of this token. Represents literal character data in interpolated string expression. The actual text of this token. Represents a Decimal literal token. The actual text of this token. Represents a Date literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. The list of tokens that were skipped by the parser. Represents a documentation comment e.g. ''' <Summary> appearing in source. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. ExpressionSyntax node representing the object conditionally accessed. The expression on the left-hand-side of the "?". "?" token. ExpressionSyntax node representing the access expression to be executed when the object is not null." Represents a NameOf expression. The "NameOf" keyword. The "(" token. The argument. The ")" token. Represents an interpolated string expression. The opening '$"', '$“', or '$”' token. The contents of the interpolated string. The closing '"', '”', or '“' token. Represents literal text content in an interpolated string. The text token. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. The opening curly brace '{' token. The expression whose formatted value should be embedded in the resultant string. Optional. The alignment clause ',alignment' of the embedded expression. Optional. The format string clause ':formatString' of the embedded expression. The closing curly brace '}' token of the embedded expression. Represents an alignment clause ',alignment' of an interpolated string embedded expression. The comma ',' token. An expression representing the alignment of the interpolated expression. Represents a format string clause ':formatString' of an interpolated string embedded expression. The ':' token. The format string. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. A representing the specific kind of SyntaxTrivia. One of WhitespaceTrivia, EndOfLineTrivia, ColonTrivia, CommentTrivia, ConflictMarkerTrivia, LineContinuationTrivia, DocumentationCommentExteriorTrivia, DisabledTextTrivia. The actual text of this token. Represents a #Const pre-processing constant declaration appearing in source. The "#" token in a preprocessor directive. The "Const" keyword. The name of the pre-processing constant being defined. The "=" token. An expression representing the value of the pre-processing constant being defined. Represents the beginning of an #If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of an #If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #Else pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #End If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of a #Region directive appearing in source. The "#" token in a preprocessor directive. The "Region" keyword. The label of the code region being defined. Represents an #End Region directive appearing in source. The "#" token in a preprocessor directive. The "End" keyword. The "Region" keyword. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #End ExternalSource pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #ExternalChecksum pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents #Enable Warning pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents #Disable Warning pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #r directive appearing in scripts. The "#" token in a preprocessor directive. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. The "#" token in a preprocessor directive. Create an identifier node without brackets or type character. Create an identifier node with brackets or type character. Create an identifier node without brackets or type character or trivia. Create a missing identifier. Create a missing contextual keyword. Create a missing keyword. Create a missing punctuation mark. Create a missing string literal. Create a missing character literal. Create a missing integer literal. Creates a copy of a token. The new token Create an end-of-text token. Create an end-of-text token. A class to represent an empty statement. This can occur when a colon is on a line without anything else. An empty token because all non terminals must have a token. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. A representing the specific kind of EndBlockStatementSyntax. One of EndIfStatement, EndUsingStatement, EndWithStatement, EndSelectStatement, EndStructureStatement, EndEnumStatement, EndInterfaceStatement, EndClassStatement, EndModuleStatement, EndNamespaceStatement, EndSubStatement, EndFunctionStatement, EndGetStatement, EndSetStatement, EndPropertyStatement, EndOperatorStatement, EndEventStatement, EndAddHandlerStatement, EndRemoveHandlerStatement, EndRaiseEventStatement, EndWhileStatement, EndTryStatement, EndSyncLockStatement. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an entire source file of VB code. Represents the list of Option statements at the beginning of a source file. Represents the list of Imports statements at the beginning of a source file. Represents the list of AttributeStatements at the beginning of a source file that contain the Assembly and Module attributes. Represents the members of the default namespace for this source file: all the top-level type and namespace declarations in the file. May also contain Statements that are not valid Represents the end of the source file. This token may have trivia (whitespace, comments, ...) attached to it. Represents an Option statement, such as "Option Strict On". The "Option" keyword. The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. The keyword that identifiers the value being set for the option: On, Off, Text or Binary. Represents an Imports statement, which has one or more imports clauses. The "Imports" keyword. A list of one or more import clauses. Each clause is either an alias, namespace or XML namespace import. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. An optional alias for the namespace or type being imported. The namespace or type being imported. Represents an alias identifier followed by an "=" token in an Imports clause. The identifier being introduced. The "=" token. Defines a XML namespace for XML expressions. Identifies the XML namespace alias and URI. Represents a Namespace statement, its contents and the End Namespace statement. The statement that begins the NamespaceBlock. The declarations contained in the namespace statement. The End Namespace statement that ends the block. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. The "Namespace" keyword. A (possibly dotted) name denoting the namespace being declared. Represents a declaration of Module, its contents and the End statement that ends it. The "Module" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Module" statement that ends the block. Represents a declaration of a Structure, its contents and the End statement that ends it. The "Structure" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Structure" statement that ends the block. Represents a declaration of a Interface, its contents and the End statement that ends it. The "Interface" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Interface" statement that ends the block. Represents a declaration of a Class its contents and the End statement that ends it. The "Class" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Class" statement that ends the block. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. The statement that begins the type or module. The declarations contained in the enumeration. The End XXX statement that ends the block. Represents an Inherits statement in a Class, Structure or Interface. The "Inherits" keyword. A list of the types being inherited. Represents an Implements statement in a Class or Structure. The "Implements" keyword. A list of the types being implemented. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Module" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Structure" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Interface" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Class" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Enum" keyword. The name of the enum being declared. Optional "As XXX" clause describing the underlying type of the enumeration. If no As clause was specified, Nothing is returned. Represents the type parameter list in a declaration. The "(" token. The "Of" keyword. A list of the type parameters. There must be at least one type parameter in the list. The ")" token. Represents a type parameter on a generic type declaration. Represents the "In" or "Out" variance keyword on a type parameter, if present. If no variance modifier was present, Nothing is returned. The name of the type parameter The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. A list of the supplied constraints. If no constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". The "As" keyword. The "{" token. A list of the supplied constraints. If no constraints were supplied, an empty list is returned. The "}" token. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. A representing the specific kind of SpecialConstraintSyntax. One of NewConstraint, ClassConstraint, StructureConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. Represents a type parameter constraint that is a type. The type describing the constraint. Represents a name and value in an EnumDeclarationBlock. An optional value for the enum member. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. A representing the specific kind of MethodBlockSyntax. One of SubBlock, FunctionBlock. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub New" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" statement that ends the block declaration. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Operator" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Operator" statement that ends the block declaration. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. A representing the specific kind of AccessorBlockSyntax. One of GetAccessorBlock, SetAccessorBlock, AddHandlerAccessorBlock, RemoveHandlerAccessorBlock, RaiseEventAccessorBlock. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. The property declaration that begins the block. The accessor blocks contained in the property, between the Property and the End Property statements. The End Property statement that ends the block. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. The event declaration that begins the block. The accessor blocks contained in the custom event declaration, between the Event statement and the End Event statement. The End Event statement that ends the block. Represents the parameter list in a method declaration. The "(" token that introduces the parameter list. If no parameter list was present, Nothing is returned. The list of parameters. If no parameter list was present, Nothing is returned. The ")" token that concludes the parameter list. If no parameter list was present, Nothing is returned. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A representing the specific kind of MethodStatementSyntax. One of SubStatement, FunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" keyword. The "New" keyword in the constructor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A representing the specific kind of DeclareStatementSyntax. One of DeclareSubStatement, DeclareFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A representing the specific kind of DelegateStatementSyntax. One of DelegateSubStatement, DelegateFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The optional Custom keyword for custom event declarations. The "Event" keyword that introduces this event declaration. The name of the event being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an Implements clause indicates the interface methods that this method implements. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Operator" keyword that introduces this operator declaration. The operator being defined. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Property" keyword that introduces this property declaration. The name of the property being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the property. If present, an Implements clause indicated the interface methods that this method implements. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A representing the specific kind of AccessorStatementSyntax. One of GetAccessorStatement, SetAccessorStatement, AddHandlerAccessorStatement, RemoveHandlerAccessorStatement, RaiseEventAccessorStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. The "Implements" keyword. The list of interface members being implemented. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. The "Handles" keyword. The list of event members being handled. Represents event container specified through special keywords "Me", "MyBase" or "MyClass".. The container of the event. This can be one of the special keywords: "Me", "MyBase" or "MyClass". Represents event container that refers to a WithEvents member. The container of the event. It is a simple identifier that refers to a WithEvents member of the containing type. Represents event container that refers to a WithEvents member's property. The container of the event. The "." token. The provider of the event. It is a property of a WithEvents member of the containing type. Represents a single handled event in a "Handles ..." clause. The container of the event. This can either be a simple identifier (identifying a members of the containing type) or one of the special keywords "Me", "MyBase" or "MyClass". The "." token. The event being handled. This must be a simple identifier. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The missing identifier token for this incomplete member. Should only be used to have a location for error reporting. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. The "As" clause that describes the return type, and possibly includes "New", "With" or "From". If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the variable or the value of the constant. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. The "As" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type-name part of the As clause. Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) The "As" keyword. The New expression Represents a "With {...} clause used to initialize a new object's members. The "With" keyword. The "{" token. The comma-separated list of field initializers. The "}" token. Represents a "From {...} clause used to initialize a new collection object's elements. The "From" keyword. The initializer including the braces. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. The optional "Key" keyword. The value being assigned. Represent a named field initializer in a With {...} initializer, such as ".x = expr". The optional "Key" keyword. The "." token. The name of the field being initialized. The "=" token. The value being assigned to the field. Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. The "=" token. The expression used as the initial value. Represent a parameter to a method, property, constructor, etc. A list of all attribute lists on this parameter. If no attributes were specified, Nothing is returned. A list of the modifier tokens "ByVal", "ByRef", "Optional" or "ParamArray" that modify this parameter. The name of the parameter, including any "?" or "()" modifiers. If present, the "As type-name" clause describing the type of the parameter. If no As clause is present, Nothing is returned. If present, an initializer with the default value of the parameter. If no default value is present, Nothing is returned. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. The "?" token that indicates a nullable type. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". A list of array modifiers for the type. If no array modifiers were present, an empty list is returned. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". The "(" token. The comma tokens in the array type. There is one less comma than the rank. The ")" token. Represents a group of attributes within "<" and ">" brackets. The "<" token. A comma separated list of attribute declarations in this attribute list. The ">" token. Represents a single attribute declaration within an attribute list. Optional attribute target. Assembly|Module : The name of the attribute. The argument list, if present. If no argument list was supplied, Nothing is returned. Represents a single attribute declaration within an attribute list. The "Assembly" or "Module" attribute modifier, is present. If no attribute modifier is present, Nothing is returned. The ":" token, if an attribute modifier is present. If no attribute modifier is present, Nothing is returned. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. The list of attribute lists. Represent an expression in a statement context. This may only be a invocation or await expression in standard code but may be any expression in VB Interactive code. The expression. Represent a "? expression" "Print" statement in VB Interactive code. "?" token. The expression whose value is being output. Represents a While...End While statement, including the While, body and End While. The While statement that begins the block. The statements contained in the While...End While. This might be an empty list. The End While statement that ends the block. Represents an entire Using...End Using statement, including the Using, body and End Using statements. The UsingStatement that begins the Using...End Using block. The statements contained in the Using...End Using block. This might be an empty list. The End Using statement that ends the block. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. The SyncLock statement that begins the block. The statements contained in the SyncLock...End SyncLock statement. This might be an empty list. The End SyncLock statement that ends the block. Represents a With...End With block, include the With statement, the body of the block and the End With statement. The WithStatement that begins the With...End With block. The statements contained in the With...End With block. This might be an empty list. The End With statement that ends the block. Represents the declaration of one or more local variables or constants. The modifier token (Static, Dim or Const) that introduces this local variable declaration. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents a label statement. The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. The ":" token of the label statement. Represents a "GoTo" statement. The "GoTo" keyword. The name of the label. If the label is a line number, wraps an IntegerLiteral that is the line number, otherwise, wraps an Identifier. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A representing the specific kind of LabelSyntax. One of IdentifierLabel, NumericLabel, NextLabel. The label name (identifier), line number (integer literal), or next keyword token. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. A representing the specific kind of StopOrEndStatementSyntax. One of StopStatement, EndStatement. The "Stop" or "End" keyword. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. A representing the specific kind of ExitStatementSyntax. One of ExitDoStatement, ExitForStatement, ExitSubStatement, ExitFunctionStatement, ExitOperatorStatement, ExitPropertyStatement, ExitTryStatement, ExitSelectStatement, ExitWhileStatement. The "Exit" keyword. The keyword describing the block to exit. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. A representing the specific kind of ContinueStatementSyntax. One of ContinueWhileStatement, ContinueDoStatement, ContinueForStatement. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Return" statement. The "Return" keyword. The expression being returned, if present. Represents a single-line "If ... Then ... Else ..." statement. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. A list of statements to be executed if the condition expression evaluates as true. Multiple statements must be separated by colons. An "Else" clause to be executed if the condition expression evaluates as false. Represents the "Else ..." clause of a single-line "If" statement. The "Else" keyword. A list of statements to be executed. Multiple statements must be separated by colons. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. The "If" statement that begins the "If" block. A list of statements to be executed if the condition expression evaluates as true. A list of "ElseIf" blocks to be evaluated, in order, if the condition expression of the "If" statement evaluates as false. An "Else" block to be executed if the condition expression of the "If" statement and all "ElseIf" blocks evaluate as false. Then "End If" statement. Represents the "If ... Then" statement that begins a multi-line "If" block. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. Represents an "ElseIf ... Then ..." block. The "ElseIf ... Then" statement the begins the "ElseIf" block. A list of statements to be executed if the condition expression of the "ElseIf" statement evaluates as true. Represents the "ElseIf ... Then" statement that begins an "ElseIf" block. The "ElseIf" keyword. The condition expression to be evaluated. The "Then" keyword. Represents an "Else ..." block. The "Else" statement that begins the "Else" block. A list of statements to be executed. Represents the "Else" statement that begins an "Else" block. The "Else" keyword. Represents a "Try ... Catch ... Finally ... End Try" block. The "Try" statement that begins the "Try" block. A list of statements to be executed. A list of "Catch" blocks which may be executed if an exception is thrown while executing the statements in the "Try" block. A "Finally" block to be executed before execution leaves the "Try" block. The "End Try" statement. Represents the "Try" statement that begins a "Try" block. The "Try" keyword. Represents a "Catch ..." block. The "Catch" statement that begins the "Catch" block. A list of statements to be executed if an exception is caught by the "Catch" block. Represents the "Catch ... When ..." statement that begins a "Catch" block. The "Catch" keyword. An identifier declaring a new variable or naming an existing variable to store the exception caught by the "Catch" statement. A simple "As" clause specifying the type of exception to catch. A "When" clause to filter exceptions before catching. Represents the "When ..." clause of a "Catch" statement. The "When" keyword. The filter expression to be evaluated. Represents a "Finally ..." block of a "Try" block. The "Finally" statement that begins the "Finally" block. A list of statements to be executed. Represents the "Finally" statement that begins a "Finally" block. The "Finally" keyword. Represents the "Error" statement. The "Error" keyword. The expression that represents the error number. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. A representing the specific kind of OnErrorGoToStatementSyntax. One of OnErrorGoToZeroStatement, OnErrorGoToMinusOneStatement, OnErrorGoToLabelStatement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Resume Next statement. The "On" keyword The "Error" keyword. The "Resume" keyword. The "Next" Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. The Select Case statement that begins the block. A list of the contained Case blocks. The End Select statement that ends the block. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. The "Select" keyword. The "Case" keyword, if present. The value that branching is based on. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. The "Else" part in a Case Else statement. The "Else" keyword. Represents a single value in a Case. The expression that denotes the value being tested against. Represents a range "expression To expression" in a Case. The lower bound of the range. The "To" keyword The upper bound of the range. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". A representing the specific kind of RelationalCaseClauseSyntax. One of CaseEqualsClause, CaseNotEqualsClause, CaseLessThanClause, CaseLessThanOrEqualClause, CaseGreaterThanOrEqualClause, CaseGreaterThanClause. The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. The "SyncLock" keyword. The expression being synchronized on. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. A representing the specific kind of DoLoopBlockSyntax. One of SimpleDoLoopBlock, DoWhileLoopBlock, DoUntilLoopBlock, DoLoopWhileBlock, DoLoopUntilBlock. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. A representing the specific kind of DoStatementSyntax. One of SimpleDoStatement, DoWhileStatement, DoUntilStatement. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. A representing the specific kind of LoopStatementSyntax. One of SimpleLoopStatement, LoopWhileStatement, LoopUntilStatement. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. A representing the specific kind of WhileOrUntilClauseSyntax. One of WhileClause, UntilClause. The "While" or "Until" keyword. The boolean expression after the While or Until. The While statement that begins a While...End While block. This statement always occurs as the Begin of a WhileBlock. The "While" keyword. The boolean expression that controls the While loop. Represents a For block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For statement that begins the block. The statements contained in the For or For Each loop. This might be an empty list. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. Represents a For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For Each statement that begins the block. The statements contained in the For or For Each loop. This might be an empty list. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "For" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The "=" token. The expression denoting the initial value of the iteration. The "To" keyword. The expression denoting the final value of the iteration. The optional Step clause. The Step clause in a For Statement. The "Step" keyword. The expression denoting the step increment. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "For" keyword. The "Each" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The "In" keyword. The expression denoting the collection to iterate over. The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The "Next" keyword. The variables in the Next statement, if present The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. The "Using" keyword. If the Using statement is of a form that does not declare a new variable, this is the expression used in the using. Otherwise, Nothing is returned. If the Using statement is of a form that declares one or more new variables, this is the list of variable declarations. Otherwise, Nothing is returned. Represents a Throw statement. The "Throw" keyword The expression denoting the value being thrown. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. A representing the specific kind of AssignmentStatementSyntax. One of SimpleAssignmentStatement, MidAssignmentStatement, AddAssignmentStatement, SubtractAssignmentStatement, MultiplyAssignmentStatement, DivideAssignmentStatement, IntegerDivideAssignmentStatement, ExponentiateAssignmentStatement, LeftShiftAssignmentStatement, RightShiftAssignmentStatement, ConcatenateAssignmentStatement. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a left-hand side of a MidAssignment statement. The "Mid" possibly followed by a type character. The argument list. Represent a call statement (also known as a invocation statement). The "Call" keyword. The expression denoting the call. This could be an Invocation or a MemberAccess (in the case where no parentheses were supplied.) Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. A representing the specific kind of AddRemoveHandlerStatementSyntax. One of AddHandlerStatement, RemoveHandlerStatement. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represent a RaiseEvent statement. The "RaiseEvent" keyword The name of the event being raised. The argument list, if present. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. The "With" keyword. The expression that is the operand of the With statement. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement clause. The target of the ReDim statement. The ArraySizeInitializationModifier. Represents an "Erase" statement. The "Erase" keyword. A list of expressions denoting the arrays to erase. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. A representing the specific kind of LiteralExpressionSyntax. One of CharacterLiteralExpression, TrueLiteralExpression, FalseLiteralExpression, NumericLiteralExpression, DateLiteralExpression, StringLiteralExpression, NothingLiteralExpression. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a parenthesized expression. The "(" token The expression inside the parentheses. The ")" token Represents a tuple literal expression. The "(" token The list of tuple arguments. The ")" token Represents a tuple type expression. The "(" token The list of tuple elements. The ")" token Represents a single declaration of a tuple element supplying only the type. The type-name part of the tuple element syntax. Represents a single declaration of a tuple element supplying element name and optionally a type. The name of the element. A simple "As" clause specifying the type of the tuple element. Identifies the special instance "Me" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "MyBase" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "MyClass" The "Me", "MyClass" or "MyBase" keyword. Represents a GetType expression. The "GetType" keyword. The "(" token. The type to get the Type object for. This can be an open generic type. The ")" token. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. A representing the specific kind of TypeOfExpressionSyntax. One of TypeOfIsExpression, TypeOfIsNotExpression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a GetXmlNamespace expression. The "GetXmlNamespace" keyword. The "(" token. The Xml namespace name being referenced. The ")" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. A representing the specific kind of MemberAccessExpressionSyntax. One of SimpleMemberAccessExpression, DictionaryAccessExpression. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. A representing the specific kind of XmlMemberAccessExpressionSyntax. One of XmlElementAccessExpression, XmlDescendantAccessExpression, XmlAttributeAccessExpression. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. The target of the call or index expression. The argument list. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type of the object being initialized. The argument list, if present. If no argument list was supplied, Nothing is returned. An optional From or With clause to initialize the new object. Represents a New expression that create an object of anonymous type. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The With clause to initialize the new object. Represents an expression that creates a new array. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The element type of the array being created. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". A list of array modifiers such as "()" or "(,)". If no array modifiers were present, an empty list is returned. The initializer including the braces. Represents an expression that creates a new array without naming the element type. The "{" token. The list of initializers between the braces. The "}" token. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. The keyword that was used in the cast operation. The "(" token. The expression being cast. The ")" token. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. A representing the specific kind of BinaryExpressionSyntax. One of AddExpression, SubtractExpression, MultiplyExpression, DivideExpression, IntegerDivideExpression, ExponentiateExpression, LeftShiftExpression, RightShiftExpression, ConcatenateExpression, ModuloExpression, EqualsExpression, NotEqualsExpression, LessThanExpression, LessThanOrEqualExpression, GreaterThanOrEqualExpression, GreaterThanExpression, IsExpression, IsNotExpression, LikeExpression, OrExpression, ExclusiveOrExpression, AndExpression, OrElseExpression, AndAlsoExpression. The left operand. The right operand. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. A representing the specific kind of UnaryExpressionSyntax. One of UnaryPlusExpression, UnaryMinusExpression, NotExpression, AddressOfExpression. The token that is the operator. The expression being operated on. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a single line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a single line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a single line lambda expression. A representing the specific kind of SingleLineLambdaExpressionSyntax. One of SingleLineFunctionLambdaExpression, SingleLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. A representing the specific kind of MultiLineLambdaExpressionSyntax. One of MultiLineFunctionLambdaExpression, MultiLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A representing the specific kind of LambdaHeaderSyntax. One of SubLambdaHeader, FunctionLambdaHeader. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents a parenthesized argument list. The "(" token. The list of arguments. This may be empty. Omitted argument are represented by an OmittedArgumentSyntax node. The ")" token. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. An empty token because all non terminals must have a token. Represents an argument that is just an optional argument name and an expression. The optional name and ":=" prefix of a named argument. The expression that is the argument. Represents an identifier name followed by a ":=" token in a named argument. The name used to identify the named argument. The ":=" token. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. The lower bound of the range. This is typically the integer constant zero. The "To" keyword. The upper bound of the range. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. A list of all the query operators in this query expression. This list always contains at least one operator. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. The name of the range variable being defined. Describes the type of the variable being defined. The "In" keyword. The expression that serves as the source of items for the range variable. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the expression. The expression used to initialize the expression variable. Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the aggregation expression. The name of the aggregation function. The "Group" aggregation function is represented by the identifier "Group". Represents the name and optional type of an expression range variable. The name of the variable being defined. Describes the type of the variable being defined. The "=" token. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. The "(" token if present. The argument to the aggregation function. The ")" token, if present. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. The "Group" keyword. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. The "From" keyword. The list of collection variables declared by this From operator. Represents a "Let" query operator. The "Let" keyword. The list of expression range variable being defined by the Let operator. Represents an Aggregate query operator. The "Aggregate" keyword. The list of collection range variables declared by this Aggregate operator. A list of additional query operators. It may be empty. The "Into" keyword. The list of new variables being defined by the aggregation. Represents the "Distinct" query operator. The "Distinct" keyword. Represents a "Where" query operator. The "Where" keyword. The boolean expression used for filtering. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. A representing the specific kind of PartitionWhileClauseSyntax. One of SkipWhileClause, TakeWhileClause. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. A representing the specific kind of PartitionClauseSyntax. One of SkipClause, TakeClause. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents the "Group By" query operator. The "Group" keyword. The optional list of variables being grouped; the contents of the Group clause. If none were specified, an empty list is returned. The "By" keyword. The key values being used for grouping. The list of new variables that calculate aggregations. Represents the "expression Equals expression" condition in a Join. The left expression in the Join condition. The "Equals" keyword. The right expression in the Join condition. Represents a Join query operator. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Represents the "Group Join" query operator. The "Group" keyword. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. The "Into" keyword. The list of new variables that calculate aggregations. Represents the "Order By" query operator. The "Order" keyword The "By" keyword. The list of OrderExpression's to sort by. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. A representing the specific kind of OrderingSyntax. One of AscendingOrdering, DescendingOrdering. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. Represents the "Select" query operator. The "Select" keyword. The list of expression range variables being defined by the Select query operator. Represents an XML Document literal expression. Represents the XML declaration prologue in an XML literal expression. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. Represents an XML element with content in an XML literal expression. Represents Xml text. A list of all the text tokens in the Xml text. This list always contains at least one token. Represents the start tag of an XML element of the form <element>. Represents the end tag of an XML element of the form </element>. Represents an empty XML element of the form <element /> Represents an XML attribute in an XML literal expression. Represents a string of XML characters embedded as the content of an XML element. Represents an XML name of the form 'name' appearing in GetXmlNamespace(). Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. Represents an XML CDATA section in an XML literal expression. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. The type of the elements of the array. Represents the list of "()" or "(,,)" modifiers on the array type. A type name that represents a nullable type, such as "Integer?". The kind of type that is this type is a nullable of. Cannot be an array type or a nullable type. The "?" token. Represents an occurrence of a Visual Basic built-in type such as Integer or String in source code. The keyword that was used to describe the built-in type. Represents a type name consisting of a single identifier (which might include brackets or a type character). The identifier in the name. Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). The identifier in the name. The generic argument list. Represents a qualified type name, for example X.Y or X(Of Z).Y. The part of the name that appears to the left of the dot. This can itself be any name. The "." token that separates the names. The part of the name that appears to the right of the dot. This must be a simple identifier. Represents a name in the global namespace. The "Global" keyword. Represents a parenthesized list of generic type arguments. The "(" token. The "Of" keyword. A list of all the type arguments. The ")" token. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. Represent a Yield statement. The "Yield" keyword. The expression whose value is being yielded. Represents an Await expression. The "Await" keyword. The expression being awaited. Represents an Xml NCName per Namespaces in XML 1.0 The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. A representing the specific kind of XmlTextTokenSyntax. One of XmlTextLiteralToken, XmlEntityLiteralToken, DocumentationCommentLineBreakToken. The actual text of this token. Represents literal character data in interpolated string expression. The actual text of this token. Represents a Decimal literal token. The actual text of this token. Represents a Date literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. The list of tokens that were skipped by the parser. Represents a documentation comment e.g. ''' <Summary> appearing in source. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. ExpressionSyntax node representing the object conditionally accessed. The expression on the left-hand-side of the "?". "?" token. ExpressionSyntax node representing the access expression to be executed when the object is not null." Represents a NameOf expression. The "NameOf" keyword. The "(" token. The argument. The ")" token. Represents an interpolated string expression. The opening '$"', '$“', or '$”' token. The contents of the interpolated string. The closing '"', '”', or '“' token. Represents literal text content in an interpolated string. The text token. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. The opening curly brace '{' token. The expression whose formatted value should be embedded in the resultant string. Optional. The alignment clause ',alignment' of the embedded expression. Optional. The format string clause ':formatString' of the embedded expression. The closing curly brace '}' token of the embedded expression. Represents an alignment clause ',alignment' of an interpolated string embedded expression. The comma ',' token. An expression representing the alignment of the interpolated expression. Represents a format string clause ':formatString' of an interpolated string embedded expression. The ':' token. The format string. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. A representing the specific kind of SyntaxTrivia. One of WhitespaceTrivia, EndOfLineTrivia, ColonTrivia, CommentTrivia, ConflictMarkerTrivia, LineContinuationTrivia, DocumentationCommentExteriorTrivia, DisabledTextTrivia. The actual text of this token. Represents a #Const pre-processing constant declaration appearing in source. The "#" token in a preprocessor directive. The "Const" keyword. The name of the pre-processing constant being defined. The "=" token. An expression representing the value of the pre-processing constant being defined. Represents the beginning of an #If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of an #If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #Else pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #End If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of a #Region directive appearing in source. The "#" token in a preprocessor directive. The "Region" keyword. The label of the code region being defined. Represents an #End Region directive appearing in source. The "#" token in a preprocessor directive. The "End" keyword. The "Region" keyword. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #End ExternalSource pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #ExternalChecksum pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents #Enable Warning pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents #Disable Warning pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #r directive appearing in scripts. The "#" token in a preprocessor directive. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. The "#" token in a preprocessor directive. Returns the statement if there is exactly one in the body, otherwise returns Nothing. Return an empty body if the body is a single, zero-width EmptyStatement, otherwise returns the entire body. Parse GetType, GetTypeExpression -> GetType OpenParenthesis GetTypeTypeName CloseParenthesis Parse NameOf, NameOfExpression -> NameOf OpenParenthesis Name CloseParenthesis Parse TypeOf ... Is ... or TypeOf ... IsNot ... TypeOfExpression -> "TypeOf" Expression "Is|IsNot" LineTerminator? TypeName Transition from scanning XML to scanning VB. As a result, any single line trivia is consumed and appended to the token which is assumed to be the token at the transition point. After VB15.5 it is possible to use named arguments in non-trailing position, except in attribute lists (where it remains disallowed) ParseCast parses CType, DirectCast, TryCast. CCCastExpression -> DirectCast ( CCExpression , TypeName ) | TryCast ( CCExpression , TypeName ) | CType ( CCExpression , TypeName ) { | CastTarget ( CCExpression ) } Cast Dev10 ParseCType does not parse exact grammar in the spec, since dev10 accepts Expression whereas the grammar uses CCExpression. This function only does not parse CastTarget ( ... ), it is parsed in ParseTerm gets the last token that has nonzero FullWidth. NOTE: this helper will not descend into structured trivia. gets the last token regardless if it has zero FullWidth or not NOTE: this helper will not descend into structured trivia. Adjust the trivia on a node so that missing tokens are always before newline and colon trivia. Because new lines and colons are eagerly attached as trivia, missing tokens can end up incorrectly after the new line. This method moves the trailing non-whitespace trivia from the last token to the last zero with token. Slow part of AdjustTriviaForMissingTokensCore where we actually do the work when we need to. Parses a CollectionInitializer CollectionInitializer -> "{" CollectionInitializerList "}" CollectionInitializerList -> CollectionElement {"," CollectionElement}* CollectionElement -> Expression | CollectionInitializer CollectionInitializerSyntax In the grammar ArrayLiteralExpression is a rename of CollectionInitializer Parses "With "{" FieldInitializerList "}" FieldInitializerList -> FieldInitializer {"," FieldInitializer}* FieldInitializer -> {Key? "." IdentifierOrKeyword "="}? Expression e.g. Dim x as new Customer With {.Id = 1, .Name = "A"} ObjectMemberInitializer Parses an ObjectCollectionInitializer ObjectCollectionInitializer -> "from" CollectionInitializer ObjectCollectionInitializer In Dev10 this was called ParseInitializerList. It also took several boolean parameters. These were always set as AllowExpressionInitializers = true AllowAssignmentInitializers = false AnonymousTypeInitializer = false RequireAtleastOneInitializer = false While the grammar uses the nonterminal CollectionInitializer is modeled as an AnonymousArrayCreationExpression which has the identical syntax "{" Expression {"," Expression }* "}" Parses a FieldInitializer FieldInitializer -> ("key"? "." IdentifierOrKeyword "=")? Expression If true then allow the keyword "key" to prefix the field initializer Parse and return a TypeName. Assumes the CurrentToken is on the name. Controls generic argument parsing Controls generic argument parsing TypeName Parameter -> Attributes? ParameterModifiers* ParameterIdentifier ("as" TypeName)? ("=" ConstantExpression)? >This replaces both ParseParameter and ParseOptionalParameter in Dev10 Parse a CustomEventMemberDeclaration This code used to be in ParseEventDefinition. Peeks in a stream of VB tokens. Note that the first token will be picked according to _allowLeadingMultilineTrivia The rest will be picked as regular VB as scanner does not always know what to do with line terminators and we assume that multiple token lookahead makes sense inside a single statement. Consumes current token and gets the next one with desired state. Consumes current node and gets next one. Check to see if the given is available with the of the parser. If it is not available a diagnostic will be added to the returned value. Returns false and reports an error if the feature is un-available Create a bad statement. Report an error only if the statement doesn't have one already If set to true a new missing identifier will be created and added to the incomplete member. If set to true the error will be attached to the first skipped token of the incomplete member. Resyncs to next statement terminator. Used in Preprocessor If the current token is a newline statement terminator, then consume the token. True if the statement terminator was consumed Parses StringLiteral LiteralNode If the current Token is not StringLiteral then returns LiteralNode with missing token. Check that the current token is the expected kind, the current node is consumed and optionally a new line after the token. The expected node kind. A token of the expected kind. This node may be an empty token with an error attached to it Since nodes are immutable, the only way to create nodes with errors attached is to create a node without an error, then add an error with this method to create another node. Checks if the resulting Cref or Name attribute value has valid trivia Note, this may be applicable not only to regular trivia, but also to syntax nodes added to trivia when the parser was recovering from errors Checks if the given is a colon trivia whose string representation is the COLON (U+003A) character from ASCII range (specifically excluding cases when it is the FULLWIDTH COLON (U+FF1A) character). See also: http://fileformat.info/info/unicode/char/FF1A A VB syntax node to check. Base class of a compile time constant. Represents a compile time constant. Candidate nodes that may be reused. The text changes combined into a single region. The range from which we cannot reuse nodes. Current node. Not necessarily reusable or even a NonTerminal. Can be null if we are out of nodes. preprocessor state before _currentNode preprocessor state getter after _currentNode Expand the span in the tree to encompass the nearest statements that the span overlaps. Not guaranteed to return the span of a StatementSyntax. Expand the span in the tree by the maximum number of tokens required for look ahead and the maximum number of characters for look behind. Moving to the next node on the stack. returns false if we are out of nodes. Crumbles current node onto the stack and pops one node into current. Returns false if current node cannot be crumbled. Certain syntax node kinds should not be crumbled since re-using individual child nodes may complicate parsing. Advances to given position if needed (note: no way back) Gets a nonterminal that can be used for incremental. May return Nothing if such node is not available. Typically it is _currentNode. Returns current candidate for reuse if there is one. Checks if node is reusable. The reasons for it not be usable are typically that it intersects affected range. Creates red tokens for a stream of text Entry point to directive processing for Scanner. Gets an initial preprocessor state and applies all directives from a given node. Entry point for blender The possible states that the mini scanning can be in. DO NOT USE DIRECTLY. USE GetScratch() Gets a chunk of text as a DisabledCode node. The range of text. The DisabledCode node. Accept a CR/LF pair or either in isolation as a newline. Make it a statement separator Accept a CR/LF pair or either in isolation as a newline. Make it a whitespace Consumes all trivia until a nontrivia char is found Scans a single piece of trivia Scan trivia on one LOGICAL line Will check for whitespace, comment, EoL, implicit line break EoL may be consumed as whitespace only as a part of line continuation ( _ ) Return True if the builder is a (possibly empty) list of WhitespaceTrivia followed by an EndOfLineTrivia. Return True if the character is a colon, and not part of ":=". Not intended for use in Expression Compiler scenarios. Try to convert an Identifier to a Keyword. Called by the parser when it wants to force an identifier to be a keyword. page represents a cached array of chars. where page maps in the stream. Used to validate pages page's buffer current page we are reading. gets a page for the position. will initialize it if we have cache miss 0 - not a surrogate, 2 - is valid surrogate 1 is an error Crumbles currently available node (if available) into its components. The leftmost child becomes the current node. If operation is not possible (node has no children, there is no node), then returns false. Gets current reusable syntax node. If node is returned its start will be aligned with the start of current token. NOTE: Line offset may not match start of current token because of lookahead. Indicates that previously returned node has been consumed and scanner needs to advance by the size of the node. NOTE: the advancement is done relative to the start of the current token. Line offset may not match start of current token because of lookahead. This operation will discard lookahead tokens and reset preprocessor state to the state of current token. Indicates that previously returned node has been consumed and scanner needs to advance by the size of the node. NOTE: the advancement is done relative to the _lineBufferOffset. Line offset will likely not match start of current token because this operation is done while constructing the content of current token. NOTE: This operation assumes that there is no tokens read ahead. NOTE: This operation does not change preprocessor state. The assumption is that it is responsibility of the node consumer to update preprocessor state if needed when using nodes that change preprocessor state. note that state is applied only to the token #1 See description in TryScanXmlDocComment(...) This method is only to be used for parsing Cref and Name attributes as stand-alone entities Returns False if trivia ends line. Scan VB tokens Scan VB tokens but consume multiline trivia before token. Done at the start of a new statement except after line if. Scan tokens in Xml misc state, these are tokens between document declaration and the root element Scan tokens inside of <!DOCTYPE ... > Scan tokens inside of < ... > Scan tokens inside of </ ...> Scan a single quoted string Scan a single quoted string RIGHT_SINGLE_QUOTATION_MARK Scan a quoted string Scan a quoted string RIGHT_DOUBLE_QUOTATION_MARK Scan a string that is missing quotes (error recovery) Scan text between markup Scan text inside of <![CDATA[ ... ]]> Scan first text inside f <? ... ?>, the first text can have leading trivia Scan remaining text inside of <? ... ?> Scan text inside of <!-- ... --> Scan punctuation in an interpolated string. Scan interpolated string text content. Scan interpolated string format string text content (no newlines). Contextual Nodekind If true, the identifier was enclosed in brackets, such as "[End]". The text of the identifier, not including the brackets or type character. The type character suffix, if present. Returns TypeCharacter.None if no type character was present. The only allowed values are None, Integer, Long, Decimal, Single, Double, and String. Represents an identifier token. This might include brackets around the name, and a type character. Contextual Nodekind If true, the identifier was enclosed in brackets, such as "[End]". The text of the identifier, not including the brackets or type character. The type character suffix, if present. Returns TypeCharacter.None if no type character was present. The only allowed values are None, Integer, Long, Decimal, Single, Double, and String. Contextual Nodekind If true, the identifier was enclosed in brackets, such as "[End]". The text of the identifier, not including the brackets or type character. The type character suffix, if present. Returns TypeCharacter.None if no type character was present. The only allowed values are None, Integer, Long, Decimal, Single, Double, and String. The value of the token. Represents an integer literal token. Whether the token was specified in base 10, 16, 8, or 2. The type suffix or type character that was on the literal, if any. If no suffix was present, TypeCharacter.None is returned. Represents a floating literal token. The value of the token. Represents a floating literal token. The type suffix or type character that was on the literal, if any. If no suffix was present, TypeCharacter.None is returned. Return the length of the common ending between the two sets of trivia. The valid trivia (following skipped tokens) of one must be contained in the valid trivia of the other. Return the index within the trivia of what would be considered trailing single-line trivia by the Scanner. This behavior must match ScanSingleLineTrivia. In short, search walks backwards and stops at the second terminator (colon or EOL) from the end, ignoring EOLs preceded by line continuations. Add all the tokens in this node and children to the build token list builder. While doing this, add any diagnostics not on tokens to the given diagnostic info list. Represents one of the type characters or literal suffixes of VB. Used to describe a) the type character suffixes that can be placed on identifiers, and b) the suffixes that can be placed on integer literals. The "%" type character." The "&" type character." The "@" type character." The "!" type character." The "#" type character." The "$" type character." The "S" literal suffix denoting "Short" The "US" literal suffix denoting "UShort" The "I" literal suffix denoting "Integer" The "UI" literal suffix denoting "UInteger" The "L" literal suffix denoting "Long" The "UL" literal suffix denoting "ULong" The "F" literal suffix denoting "Single" The "R" literal suffix denoting "Double" The "D" literal suffix denoting "Decimal" The four possible number bases that a literal can be written in. The base class for all nodes that represent statements. This includes both declaration statements, such as class declarations as well as executable statements. The base class for all nodes that represent executable statements. The base class for all nodes that represent statements that declare options, imports, members, etc. A class to represent an empty statement. This can occur when a colon is on a line without anything else. This node is associated with the following syntax kinds: An empty token because all non terminals must have a token. Returns a copy of this with the Empty property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Empty property. Represents an "End XXX" statement, where XXX is a single keyword. This node is associated with the following syntax kinds: The "End" keyword Returns a copy of this with the EndKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Returns a copy of this with the BlockKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the EndKeyword property. The value for the BlockKeyword property. Represents an entire source file of VB code. This node is associated with the following syntax kinds: Represents the list of Option statements at the beginning of a source file. If nothing is present, an empty list is returned. Returns a copy of this with the Options property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the list of Imports statements at the beginning of a source file. If nothing is present, an empty list is returned. Returns a copy of this with the [Imports] property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the list of AttributeStatements at the beginning of a source file that contain the Assembly and Module attributes. If nothing is present, an empty list is returned. Returns a copy of this with the Attributes property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the members of the default namespace for this source file: all the top-level type and namespace declarations in the file. May also contain Statements that are not valid If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the end of the source file. This token may have trivia (whitespace, comments, ...) attached to it. Returns a copy of this with the EndOfFileToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Options property. The value for the Imports property. The value for the Attributes property. The value for the Members property. The value for the EndOfFileToken property. Returns #r directives specified in the compilation. Represents an Option statement, such as "Option Strict On". This node is associated with the following syntax kinds: The "Option" keyword. Returns a copy of this with the OptionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. Returns a copy of this with the NameKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The keyword that identifiers the value being set for the option: On, Off, Text or Binary. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ValueKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OptionKeyword property. The value for the NameKeyword property. The value for the ValueKeyword property. Represents an Imports statement, which has one or more imports clauses. This node is associated with the following syntax kinds: The "Imports" keyword. Returns a copy of this with the ImportsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of one or more import clauses. Each clause is either an alias, namespace or XML namespace import. If nothing is present, an empty list is returned. Returns a copy of this with the ImportsClauses property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ImportsKeyword property. The value for the ImportsClauses property. The base class for the possible clauses of an Imports statement. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. This node is associated with the following syntax kinds: An optional alias for the namespace or type being imported. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the [Alias] property changed to the specified value. Returns this instance if the specified value is the same as the current value. The namespace or type being imported. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Alias property. The value for the Name property. Represents an alias identifier followed by an "=" token in an Imports clause. This node is associated with the following syntax kinds: The identifier being introduced. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "=" token. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. The value for the EqualsToken property. Defines a XML namespace for XML expressions. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Identifies the XML namespace alias and URI. Returns a copy of this with the XmlNamespace property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the GreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanToken property. The value for the XmlNamespace property. The value for the GreaterThanToken property. Represents a Namespace statement, its contents and the End Namespace statement. This node is associated with the following syntax kinds: The statement that begins the NamespaceBlock. Returns a copy of this with the NamespaceStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the namespace statement. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End Namespace statement that ends the block. Returns a copy of this with the EndNamespaceStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NamespaceStatement property. The value for the Members property. The value for the EndNamespaceStatement property. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. This node is associated with the following syntax kinds: The "Namespace" keyword. Returns a copy of this with the NamespaceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A (possibly dotted) name denoting the namespace being declared. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NamespaceKeyword property. The value for the Name property. Represents a declaration of a Class, Interface, Structure, Module, its contents and the End statement that ends it. A list of the Inherits declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Inherits] property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Implements declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Implements] property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the type or module. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statement that begins the block declaration. The statement that ends the block declaration. Returns a copy of this with the property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents a declaration of Module, its contents and the End statement that ends it. This node is associated with the following syntax kinds: The "Module" statement that begins the block. Returns a copy of this with the ModuleStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Inherits declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Inherits] property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Implements declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Implements] property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the type or module. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Module" statement that ends the block. Returns a copy of this with the EndModuleStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ModuleStatement property. The value for the Inherits property. The value for the Implements property. The value for the Members property. The value for the EndModuleStatement property. Represents a declaration of a Structure, its contents and the End statement that ends it. This node is associated with the following syntax kinds: The "Structure" statement that begins the block. Returns a copy of this with the StructureStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Inherits declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Inherits] property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Implements declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Implements] property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the type or module. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Structure" statement that ends the block. Returns a copy of this with the EndStructureStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the StructureStatement property. The value for the Inherits property. The value for the Implements property. The value for the Members property. The value for the EndStructureStatement property. Represents a declaration of a Interface, its contents and the End statement that ends it. This node is associated with the following syntax kinds: The "Interface" statement that begins the block. Returns a copy of this with the InterfaceStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Inherits declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Inherits] property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Implements declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Implements] property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the type or module. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Interface" statement that ends the block. Returns a copy of this with the EndInterfaceStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the InterfaceStatement property. The value for the Inherits property. The value for the Implements property. The value for the Members property. The value for the EndInterfaceStatement property. Represents a declaration of a Class its contents and the End statement that ends it. This node is associated with the following syntax kinds: The "Class" statement that begins the block. Returns a copy of this with the ClassStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Inherits declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Inherits] property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the Implements declarations for the type. If nothing is present, an empty list is returned. Returns a copy of this with the [Implements] property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the type or module. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Class" statement that ends the block. Returns a copy of this with the EndClassStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ClassStatement property. The value for the Inherits property. The value for the Implements property. The value for the Members property. The value for the EndClassStatement property. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. This node is associated with the following syntax kinds: The statement that begins the type or module. Returns a copy of this with the EnumStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The declarations contained in the enumeration. If nothing is present, an empty list is returned. Returns a copy of this with the Members property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End XXX statement that ends the block. Returns a copy of this with the EndEnumStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the EnumStatement property. The value for the Members property. The value for the EndEnumStatement property. Represents an Inherits or Implements statement in a Class, Structure or Interface. Represents an Inherits statement in a Class, Structure or Interface. This node is associated with the following syntax kinds: The "Inherits" keyword. Returns a copy of this with the InheritsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the types being inherited. Returns a copy of this with the Types property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the InheritsKeyword property. The value for the Types property. Represents an Implements statement in a Class or Structure. This node is associated with the following syntax kinds: The "Implements" keyword. Returns a copy of this with the ImplementsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the types being implemented. Returns a copy of this with the Types property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ImplementsKeyword property. The value for the Types property. Abstract class for the beginning statement of a Module, Class, Interface or Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock, ClassDeclarationBlock, InterfaceDeclarationBlock or StructureDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns the keyword indicating the kind of declaration being made: "Class", "Structure", "Module", "Interface", etc. Returns a copy of this with the property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Module" keyword. Returns a copy of this with the ModuleKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the ModuleKeyword property. The value for the Identifier property. The value for the TypeParameterList property. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Structure" keyword. Returns a copy of this with the StructureKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the StructureKeyword property. The value for the Identifier property. The value for the TypeParameterList property. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Interface" keyword. Returns a copy of this with the InterfaceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the InterfaceKeyword property. The value for the Identifier property. The value for the TypeParameterList property. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Class" keyword. Returns a copy of this with the ClassKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the ClassKeyword property. The value for the Identifier property. The value for the TypeParameterList property. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Enum" keyword. Returns a copy of this with the EnumKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the enum being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Optional "As XXX" clause describing the underlying type of the enumeration. If no As clause was specified, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the UnderlyingType property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the EnumKeyword property. The value for the Identifier property. The value for the UnderlyingType property. Represents the type parameter list in a declaration. This node is associated with the following syntax kinds: The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Of" keyword. Returns a copy of this with the OfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the type parameters. There must be at least one type parameter in the list. Returns a copy of this with the Parameters property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the OfKeyword property. The value for the Parameters property. The value for the CloseParenToken property. Represents a type parameter on a generic type declaration. This node is associated with the following syntax kinds: Represents the "In" or "Out" variance keyword on a type parameter, if present. If no variance modifier was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the VarianceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type parameter Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterConstraintClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the VarianceKeyword property. The value for the Identifier property. The value for the TypeParameterConstraintClause property. An abstract node class that is the parent of classes that describe type parameter constraint clauses. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". This node is associated with the following syntax kinds: The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. Returns a copy of this with the AsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the supplied constraints. If no constraints were supplied, Nothing is returned. Returns a copy of this with the Constraint property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AsKeyword property. The value for the Constraint property. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". This node is associated with the following syntax kinds: The "As" keyword. Returns a copy of this with the AsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "{" token. Returns a copy of this with the OpenBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the supplied constraints. If no constraints were supplied, an empty list is returned. Returns a copy of this with the Constraints property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "}" token. Returns a copy of this with the CloseBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AsKeyword property. The value for the OpenBraceToken property. The value for the Constraints property. The value for the CloseBraceToken property. An abstract node class that is the parent of classes that describe type parameter constraints. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. This node is associated with the following syntax kinds: The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. Returns a copy of this with the ConstraintKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the ConstraintKeyword property. Represents a type parameter constraint that is a type. This node is associated with the following syntax kinds: The type describing the constraint. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Type property. Represents a name and value in an EnumDeclarationBlock. This node is associated with the following syntax kinds: If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. An optional value for the enum member. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Identifier property. The value for the Initializer property. Represents a block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include methods, constructors, operators, property accessors and custom event accessors. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statement that begins the block declaration. The statement that ends the block declaration. Returns a copy of this with the property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. This node is associated with the following syntax kinds: The "Sub" or "Function" statement that begins the block. Returns a copy of this with the SubOrFunctionStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Sub" or "End Function" statement that ends the block. Returns a copy of this with the EndSubOrFunctionStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the SubOrFunctionStatement property. The value for the Statements property. The value for the EndSubOrFunctionStatement property. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. This node is associated with the following syntax kinds: The "Sub New" statement that begins the block. Returns a copy of this with the SubNewStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Sub" statement that ends the block declaration. Returns a copy of this with the EndSubStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the SubNewStatement property. The value for the Statements property. The value for the EndSubStatement property. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. This node is associated with the following syntax kinds: The "Operator" statement that begins the block. Returns a copy of this with the OperatorStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Operator" statement that ends the block declaration. Returns a copy of this with the EndOperatorStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OperatorStatement property. The value for the Statements property. The value for the EndOperatorStatement property. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. This node is associated with the following syntax kinds: The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. Returns a copy of this with the AccessorStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Returns a copy of this with the EndAccessorStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AccessorStatement property. The value for the Statements property. The value for the EndAccessorStatement property. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. This node is associated with the following syntax kinds: The property declaration that begins the block. Returns a copy of this with the PropertyStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The accessor blocks contained in the property, between the Property and the End Property statements. Returns a copy of this with the Accessors property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End Property statement that ends the block. Returns a copy of this with the EndPropertyStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the PropertyStatement property. The value for the Accessors property. The value for the EndPropertyStatement property. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. This node is associated with the following syntax kinds: The event declaration that begins the block. Returns a copy of this with the EventStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The accessor blocks contained in the custom event declaration, between the Event statement and the End Event statement. Returns a copy of this with the Accessors property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End Event statement that ends the block. Returns a copy of this with the EndEventStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the EventStatement property. The value for the Accessors property. The value for the EndEventStatement property. An abstract node class that is the parent for declarations that are "method-like"; i.e., that have a parameter list and return type. This includes methods, constructors, properties, events, operators, declares, delegates, property accessors and custom event accessors. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns the keyword indicating the kind of declaration being made: "Sub", "Function", "Event", "Property", etc. Does not return either the "Declare" or "Delegate" keywords. Returns a copy of this with the property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the parameter list in a method declaration. This node is associated with the following syntax kinds: The "(" token that introduces the parameter list. If no parameter list was present, Nothing is returned. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of parameters. If no parameter list was present, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Parameters property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token that concludes the parameter list. If no parameter list was present, Nothing is returned. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the Parameters property. The value for the CloseParenToken property. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Sub" or "Function" keyword that introduces this method declaration. Returns a copy of this with the SubOrFunctionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the method being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a Handles clause indicated the events that this method handles. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the HandlesClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, an Implements clause indicated the interface methods that this method implements. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ImplementsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AttributeLists property. The value for the Modifiers property. The value for the SubOrFunctionKeyword property. The value for the Identifier property. The value for the TypeParameterList property. The value for the ParameterList property. The value for the AsClause property. The value for the HandlesClause property. The value for the ImplementsClause property. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Sub" keyword. Returns a copy of this with the SubKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "New" keyword in the constructor declaration. Returns a copy of this with the NewKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the SubKeyword property. The value for the NewKeyword property. The value for the ParameterList property. A Declare statement that declares an external DLL method. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Declare" keyword. Returns a copy of this with the DeclareKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, the keyword that defines the string translation semantics of the external method. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the CharsetKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Sub" or "Function" keyword. Returns a copy of this with the SubOrFunctionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the method being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Lib" keyword. Returns a copy of this with the LibKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The string literal with the library name. Returns a copy of this with the LibraryName property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, the "Alias" keyword. If not present, returns Nothing. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AliasKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The string literal with the alias. If not present, returns Nothing. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AliasName property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AttributeLists property. The value for the Modifiers property. The value for the DeclareKeyword property. The value for the CharsetKeyword property. The value for the SubOrFunctionKeyword property. The value for the Identifier property. The value for the LibKeyword property. The value for the LibraryName property. The value for the AliasKeyword property. The value for the AliasName property. The value for the ParameterList property. The value for the AsClause property. A statement that declares a delegate type. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Delegate" keyword. Returns a copy of this with the DelegateKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Sub" or "Function" keyword. Returns a copy of this with the SubOrFunctionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the delegate being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the TypeParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AttributeLists property. The value for the Modifiers property. The value for the DelegateKeyword property. The value for the SubOrFunctionKeyword property. The value for the Identifier property. The value for the TypeParameterList property. The value for the ParameterList property. The value for the AsClause property. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The optional Custom keyword for custom event declarations. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the CustomKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Event" keyword that introduces this event declaration. Returns a copy of this with the EventKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the event being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, an Implements clause indicates the interface methods that this method implements. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ImplementsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the CustomKeyword property. The value for the EventKeyword property. The value for the Identifier property. The value for the ParameterList property. The value for the AsClause property. The value for the ImplementsClause property. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Operator" keyword that introduces this operator declaration. Returns a copy of this with the OperatorKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The operator being defined. Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the OperatorKeyword property. The value for the OperatorToken property. The value for the ParameterList property. The value for the AsClause property. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Property" keyword that introduces this property declaration. Returns a copy of this with the PropertyKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the property being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, an "= initial-value" clause describing the initial value of the property. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, an Implements clause indicated the interface methods that this method implements. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ImplementsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the PropertyKeyword property. The value for the Identifier property. The value for the ParameterList property. The value for the AsClause property. The value for the Initializer property. The value for the ImplementsClause property. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. Returns a copy of this with the AccessorKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AttributeLists property. The value for the Modifiers property. The value for the AccessorKeyword property. The value for the ParameterList property. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. This node is associated with the following syntax kinds: The "Implements" keyword. Returns a copy of this with the ImplementsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of interface members being implemented. Returns a copy of this with the InterfaceMembers property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ImplementsKeyword property. The value for the InterfaceMembers property. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. This node is associated with the following syntax kinds: The "Handles" keyword. Returns a copy of this with the HandlesKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of event members being handled. Returns a copy of this with the Events property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HandlesKeyword property. The value for the Events property. Represents container of an event in a Handles clause item. Represents event container specified through special keywords "Me", "MyBase" or "MyClass".. This node is associated with the following syntax kinds: The container of the event. This can be one of the special keywords: "Me", "MyBase" or "MyClass". Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. Represents event container that refers to a WithEvents member. This node is associated with the following syntax kinds: The container of the event. It is a simple identifier that refers to a WithEvents member of the containing type. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. Represents event container that refers to a WithEvents member's property. This node is associated with the following syntax kinds: The container of the event. Returns a copy of this with the WithEventsContainer property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "." token. Returns a copy of this with the DotToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The provider of the event. It is a property of a WithEvents member of the containing type. Returns a copy of this with the [Property] property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WithEventsContainer property. The value for the DotToken property. The value for the Property property. Represents a single handled event in a "Handles ..." clause. This node is associated with the following syntax kinds: The container of the event. This can either be a simple identifier (identifying a members of the containing type) or one of the special keywords "Me", "MyBase" or "MyClass". Returns a copy of this with the EventContainer property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "." token. Returns a copy of this with the DotToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The event being handled. This must be a simple identifier. Returns a copy of this with the EventMember property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the EventContainer property. The value for the DotToken property. The value for the EventMember property. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The missing identifier token for this incomplete member. Should only be used to have a location for error reporting. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the MissingIdentifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the MissingIdentifier property. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Returns a copy of this with the Declarators property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the Declarators property. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. This node is associated with the following syntax kinds: The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. Returns a copy of this with the Names property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type, and possibly includes "New", "With" or "From". If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, an "= initial-value" clause describing the initial value of the variable or the value of the constant. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Names property. The value for the AsClause property. The value for the Initializer property. Abstract node class that represents the different kinds of "As {type-name}" clauses in a declaration: simple "As" clauses and "As New" clauses. The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. The "As" keyword. Returns a copy of this with the AsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. This node is associated with the following syntax kinds: The "As" keyword. Returns a copy of this with the AsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type-name part of the As clause. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AsKeyword property. The value for the AttributeLists property. The value for the Type property. Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) This node is associated with the following syntax kinds: The "As" keyword. Returns a copy of this with the AsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The New expression Returns a copy of this with the NewExpression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AsKeyword property. The value for the NewExpression property. An abstract node class that represents a "With" or "From" clause used to initialize a new object. Represents a "With {...} clause used to initialize a new object's members. This node is associated with the following syntax kinds: The "With" keyword. Returns a copy of this with the WithKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "{" token. Returns a copy of this with the OpenBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The comma-separated list of field initializers. Returns a copy of this with the Initializers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "}" token. Returns a copy of this with the CloseBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WithKeyword property. The value for the OpenBraceToken property. The value for the Initializers property. The value for the CloseBraceToken property. Represents a "From {...} clause used to initialize a new collection object's elements. This node is associated with the following syntax kinds: The "From" keyword. Returns a copy of this with the FromKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The initializer including the braces. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the FromKeyword property. The value for the Initializer property. Abstract class that represent a single field initializer used in a "With {...}" field initializer list. The optional "Key" keyword. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the KeyKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. This node is associated with the following syntax kinds: The optional "Key" keyword. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the KeyKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The value being assigned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the KeyKeyword property. The value for the Expression property. Represent a named field initializer in a With {...} initializer, such as ".x = expr". This node is associated with the following syntax kinds: The optional "Key" keyword. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the KeyKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "." token. Returns a copy of this with the DotToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the field being initialized. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "=" token. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The value being assigned to the field. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the KeyKeyword property. The value for the DotToken property. The value for the Name property. The value for the EqualsToken property. The value for the Expression property. Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. This node is associated with the following syntax kinds: The "=" token. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression used as the initial value. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the EqualsToken property. The value for the Value property. Represent a parameter to a method, property, constructor, etc. This node is associated with the following syntax kinds: A list of all attribute lists on this parameter. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the modifier tokens "ByVal", "ByRef", "Optional" or "ParamArray" that modify this parameter. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the parameter, including any "?" or "()" modifiers. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, the "As type-name" clause describing the type of the parameter. If no As clause is present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. If present, an initializer with the default value of the parameter. If no default value is present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the [Default] property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. The value for the Modifiers property. The value for the Identifier property. The value for the AsClause property. The value for the Default property. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. This node is associated with the following syntax kinds: The identifier that names the item being declared. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "?" token that indicates a nullable type. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Nullable property changed to the specified value. Returns this instance if the specified value is the same as the current value. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ArrayBounds property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of array modifiers for the type. If no array modifiers were present, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the ArrayRankSpecifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. The value for the Nullable property. The value for the ArrayBounds property. The value for the ArrayRankSpecifiers property. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". This node is associated with the following syntax kinds: The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The comma tokens in the array type. There is one less comma than the rank. If nothing is present, an empty list is returned. Returns a copy of this with the CommaTokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the CommaTokens property. The value for the CloseParenToken property. Returns the ranks of this array rank specifier. Represents a group of attributes within "<" and ">" brackets. This node is associated with the following syntax kinds: The "<" token. Returns a copy of this with the LessThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. A comma separated list of attribute declarations in this attribute list. If nothing is present, an empty list is returned. Returns a copy of this with the Attributes property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ">" token. Returns a copy of this with the GreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanToken property. The value for the Attributes property. The value for the GreaterThanToken property. Represents a single attribute declaration within an attribute list. This node is associated with the following syntax kinds: Optional attribute target. Assembly|Module : This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Target property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the attribute. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument list, if present. If no argument list was supplied, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ArgumentList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Target property. The value for the Name property. The value for the ArgumentList property. Represents a single attribute declaration within an attribute list. This node is associated with the following syntax kinds: The "Assembly" or "Module" attribute modifier, is present. If no attribute modifier is present, Nothing is returned. Returns a copy of this with the AttributeModifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ":" token, if an attribute modifier is present. If no attribute modifier is present, Nothing is returned. Returns a copy of this with the ColonToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeModifier property. The value for the ColonToken property. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. This node is associated with the following syntax kinds: The list of attribute lists. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AttributeLists property. Represent an expression in a statement context. This may only be a invocation or await expression in standard code but may be any expression in VB Interactive code. This node is associated with the following syntax kinds: The expression. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Expression property. Represent a "? expression" "Print" statement in VB Interactive code. This node is associated with the following syntax kinds: "?" token. Returns a copy of this with the QuestionToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression whose value is being output. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the QuestionToken property. The value for the Expression property. Represents a While...End While statement, including the While, body and End While. This node is associated with the following syntax kinds: The While statement that begins the block. Returns a copy of this with the WhileStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the While...End While. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End While statement that ends the block. Returns a copy of this with the EndWhileStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WhileStatement property. The value for the Statements property. The value for the EndWhileStatement property. Represents an entire Using...End Using statement, including the Using, body and End Using statements. This node is associated with the following syntax kinds: The UsingStatement that begins the Using...End Using block. Returns a copy of this with the UsingStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the Using...End Using block. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End Using statement that ends the block. Returns a copy of this with the EndUsingStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the UsingStatement property. The value for the Statements property. The value for the EndUsingStatement property. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. This node is associated with the following syntax kinds: The SyncLock statement that begins the block. Returns a copy of this with the SyncLockStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the SyncLock...End SyncLock statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End SyncLock statement that ends the block. Returns a copy of this with the EndSyncLockStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the SyncLockStatement property. The value for the Statements property. The value for the EndSyncLockStatement property. Represents a With...End With block, include the With statement, the body of the block and the End With statement. This node is associated with the following syntax kinds: The WithStatement that begins the With...End With block. Returns a copy of this with the WithStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the With...End With block. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End With statement that ends the block. Returns a copy of this with the EndWithStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WithStatement property. The value for the Statements property. The value for the EndWithStatement property. Represents the declaration of one or more local variables or constants. This node is associated with the following syntax kinds: The modifier token (Static, Dim or Const) that introduces this local variable declaration. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Returns a copy of this with the Declarators property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Modifiers property. The value for the Declarators property. Represents a label statement. This node is associated with the following syntax kinds: The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. Returns a copy of this with the LabelToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ":" token of the label statement. Returns a copy of this with the ColonToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LabelToken property. The value for the ColonToken property. Represents a "GoTo" statement. This node is associated with the following syntax kinds: The "GoTo" keyword. Returns a copy of this with the GoToKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the label. If the label is a line number, wraps an IntegerLiteral that is the line number, otherwise, wraps an Identifier. Returns a copy of this with the Label property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GoToKeyword property. The value for the Label property. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. This node is associated with the following syntax kinds: The label name (identifier), line number (integer literal), or next keyword token. Returns a copy of this with the LabelToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the LabelToken property. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. This node is associated with the following syntax kinds: The "Stop" or "End" keyword. Returns a copy of this with the StopOrEndKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the StopOrEndKeyword property. An exit statement. The kind of block being exited can be found by examining the Kind. This node is associated with the following syntax kinds: The "Exit" keyword. Returns a copy of this with the ExitKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The keyword describing the block to exit. Returns a copy of this with the BlockKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the ExitKeyword property. The value for the BlockKeyword property. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. This node is associated with the following syntax kinds: The "Continue" keyword. Returns a copy of this with the ContinueKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Returns a copy of this with the BlockKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the ContinueKeyword property. The value for the BlockKeyword property. Represents a "Return" statement. This node is associated with the following syntax kinds: The "Return" keyword. Returns a copy of this with the ReturnKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being returned, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ReturnKeyword property. The value for the Expression property. Represents a single-line "If ... Then ... Else ..." statement. This node is associated with the following syntax kinds: The "If" keyword. Returns a copy of this with the IfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The condition expression to be evaluated. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Then" keyword. Returns a copy of this with the ThenKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed if the condition expression evaluates as true. Multiple statements must be separated by colons. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. An "Else" clause to be executed if the condition expression evaluates as false. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ElseClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the IfKeyword property. The value for the Condition property. The value for the ThenKeyword property. The value for the Statements property. The value for the ElseClause property. Represents the "Else ..." clause of a single-line "If" statement. This node is associated with the following syntax kinds: The "Else" keyword. Returns a copy of this with the ElseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed. Multiple statements must be separated by colons. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElseKeyword property. The value for the Statements property. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. This node is associated with the following syntax kinds: The "If" statement that begins the "If" block. Returns a copy of this with the IfStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed if the condition expression evaluates as true. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of "ElseIf" blocks to be evaluated, in order, if the condition expression of the "If" statement evaluates as false. If nothing is present, an empty list is returned. Returns a copy of this with the ElseIfBlocks property changed to the specified value. Returns this instance if the specified value is the same as the current value. An "Else" block to be executed if the condition expression of the "If" statement and all "ElseIf" blocks evaluate as false. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ElseBlock property changed to the specified value. Returns this instance if the specified value is the same as the current value. Then "End If" statement. Returns a copy of this with the EndIfStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the IfStatement property. The value for the Statements property. The value for the ElseIfBlocks property. The value for the ElseBlock property. The value for the EndIfStatement property. Represents the "If ... Then" statement that begins a multi-line "If" block. This node is associated with the following syntax kinds: The "If" keyword. Returns a copy of this with the IfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The condition expression to be evaluated. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Then" keyword. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ThenKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the IfKeyword property. The value for the Condition property. The value for the ThenKeyword property. Represents an "ElseIf ... Then ..." block. This node is associated with the following syntax kinds: The "ElseIf ... Then" statement the begins the "ElseIf" block. Returns a copy of this with the ElseIfStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed if the condition expression of the "ElseIf" statement evaluates as true. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElseIfStatement property. The value for the Statements property. Represents the "ElseIf ... Then" statement that begins an "ElseIf" block. This node is associated with the following syntax kinds: The "ElseIf" keyword. Returns a copy of this with the ElseIfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The condition expression to be evaluated. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Then" keyword. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ThenKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElseIfKeyword property. The value for the Condition property. The value for the ThenKeyword property. Represents an "Else ..." block. This node is associated with the following syntax kinds: The "Else" statement that begins the "Else" block. Returns a copy of this with the ElseStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElseStatement property. The value for the Statements property. Represents the "Else" statement that begins an "Else" block. This node is associated with the following syntax kinds: The "Else" keyword. Returns a copy of this with the ElseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElseKeyword property. Represents a "Try ... Catch ... Finally ... End Try" block. This node is associated with the following syntax kinds: The "Try" statement that begins the "Try" block. Returns a copy of this with the TryStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of "Catch" blocks which may be executed if an exception is thrown while executing the statements in the "Try" block. If nothing is present, an empty list is returned. Returns a copy of this with the CatchBlocks property changed to the specified value. Returns this instance if the specified value is the same as the current value. A "Finally" block to be executed before execution leaves the "Try" block. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the FinallyBlock property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End Try" statement. Returns a copy of this with the EndTryStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the TryStatement property. The value for the Statements property. The value for the CatchBlocks property. The value for the FinallyBlock property. The value for the EndTryStatement property. Represents the "Try" statement that begins a "Try" block. This node is associated with the following syntax kinds: The "Try" keyword. Returns a copy of this with the TryKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the TryKeyword property. Represents a "Catch ..." block. This node is associated with the following syntax kinds: The "Catch" statement that begins the "Catch" block. Returns a copy of this with the CatchStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed if an exception is caught by the "Catch" block. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the CatchStatement property. The value for the Statements property. Represents the "Catch ... When ..." statement that begins a "Catch" block. This node is associated with the following syntax kinds: The "Catch" keyword. Returns a copy of this with the CatchKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. An identifier declaring a new variable or naming an existing variable to store the exception caught by the "Catch" statement. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the IdentifierName property changed to the specified value. Returns this instance if the specified value is the same as the current value. A simple "As" clause specifying the type of exception to catch. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. A "When" clause to filter exceptions before catching. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the WhenClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the CatchKeyword property. The value for the IdentifierName property. The value for the AsClause property. The value for the WhenClause property. Represents the "When ..." clause of a "Catch" statement. This node is associated with the following syntax kinds: The "When" keyword. Returns a copy of this with the WhenKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The filter expression to be evaluated. Returns a copy of this with the Filter property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WhenKeyword property. The value for the Filter property. Represents a "Finally ..." block of a "Try" block. This node is associated with the following syntax kinds: The "Finally" statement that begins the "Finally" block. Returns a copy of this with the FinallyStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of statements to be executed. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the FinallyStatement property. The value for the Statements property. Represents the "Finally" statement that begins a "Finally" block. This node is associated with the following syntax kinds: The "Finally" keyword. Returns a copy of this with the FinallyKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the FinallyKeyword property. Represents the "Error" statement. This node is associated with the following syntax kinds: The "Error" keyword. Returns a copy of this with the ErrorKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression that represents the error number. Returns a copy of this with the ErrorNumber property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ErrorKeyword property. The value for the ErrorNumber property. Represents an OnError Goto statement. This node is associated with the following syntax kinds: The "On" keyword Returns a copy of this with the OnKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Error" keyword. Returns a copy of this with the ErrorKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "GoTo" keyword Returns a copy of this with the GoToKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. An optional minus for On Error Goto -1 This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Minus property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Returns a copy of this with the Label property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the OnKeyword property. The value for the ErrorKeyword property. The value for the GoToKeyword property. The value for the Minus property. The value for the Label property. Represents an OnError Resume Next statement. This node is associated with the following syntax kinds: The "On" keyword Returns a copy of this with the OnKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Error" keyword. Returns a copy of this with the ErrorKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Resume" keyword. Returns a copy of this with the ResumeKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Next" Returns a copy of this with the NextKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OnKeyword property. The value for the ErrorKeyword property. The value for the ResumeKeyword property. The value for the NextKeyword property. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. This node is associated with the following syntax kinds: The "Resume" keyword. Returns a copy of this with the ResumeKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Label property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the ResumeKeyword property. The value for the Label property. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. This node is associated with the following syntax kinds: The Select Case statement that begins the block. Returns a copy of this with the SelectStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of the contained Case blocks. If nothing is present, an empty list is returned. Returns a copy of this with the CaseBlocks property changed to the specified value. Returns this instance if the specified value is the same as the current value. The End Select statement that ends the block. Returns a copy of this with the EndSelectStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the SelectStatement property. The value for the CaseBlocks property. The value for the EndSelectStatement property. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. This node is associated with the following syntax kinds: The "Select" keyword. Returns a copy of this with the SelectKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Case" keyword, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the CaseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The value that branching is based on. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the SelectKeyword property. The value for the CaseKeyword property. The value for the Expression property. Represents a case statement and its subsequent block. This node is associated with the following syntax kinds: The statement that begins the case block. Returns a copy of this with the CaseStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the case block. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the CaseStatement property. The value for the Statements property. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. This node is associated with the following syntax kinds: The "Case" keyword Returns a copy of this with the CaseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Returns a copy of this with the Cases property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the CaseKeyword property. The value for the Cases property. Represents a single clause in a case statement. An abstract node that is the parent of different kinds of Case clauses. The "Else" part in a Case Else statement. This node is associated with the following syntax kinds: The "Else" keyword. Returns a copy of this with the ElseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElseKeyword property. Represents a single value in a Case. This node is associated with the following syntax kinds: The expression that denotes the value being tested against. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Value property. Represents a range "expression To expression" in a Case. This node is associated with the following syntax kinds: The lower bound of the range. Returns a copy of this with the LowerBound property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "To" keyword Returns a copy of this with the ToKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The upper bound of the range. Returns a copy of this with the UpperBound property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LowerBound property. The value for the ToKeyword property. The value for the UpperBound property. Represents a relation clause in a Case statement, such as "Is > expression". This node is associated with the following syntax kinds: The "Is" keyword, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the IsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression that denotes the value being tested against. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the IsKeyword property. The value for the OperatorToken property. The value for the Value property. Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. This node is associated with the following syntax kinds: The "SyncLock" keyword. Returns a copy of this with the SyncLockKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being synchronized on. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the SyncLockKeyword property. The value for the Expression property. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. This node is associated with the following syntax kinds: The Do statement that begins the block. Returns a copy of this with the DoStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the block statement. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The Loop statement that ends the block. Returns a copy of this with the LoopStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the DoStatement property. The value for the Statements property. The value for the LoopStatement property. The Do statement that begins a Do-Loop block. This node is associated with the following syntax kinds: The "Do" keyword. Returns a copy of this with the DoKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "While expression" or "Until expression" clause of the Do statement, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the WhileOrUntilClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the DoKeyword property. The value for the WhileOrUntilClause property. The Loop statement that begins a Do-Loop block. This node is associated with the following syntax kinds: The "Loop" keyword. Returns a copy of this with the LoopKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "While expression" or "Until expression" clause of the Loop statement, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the WhileOrUntilClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the LoopKeyword property. The value for the WhileOrUntilClause property. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. This node is associated with the following syntax kinds: The "While" or "Until" keyword. Returns a copy of this with the WhileOrUntilKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The boolean expression after the While or Until. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the WhileOrUntilKeyword property. The value for the Condition property. The While statement that begins a While...End While block. This statement always occurs as the Begin of a WhileBlock. This node is associated with the following syntax kinds: The "While" keyword. Returns a copy of this with the WhileKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The boolean expression that controls the While loop. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WhileKeyword property. The value for the Condition property. Represents a For or For Each block. The statements contained in the For or For Each loop. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the NextStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The For or For Each statement that begins the block. Represents a For block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). This node is associated with the following syntax kinds: The For statement that begins the block. Returns a copy of this with the ForStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the For or For Each loop. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the NextStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ForStatement property. The value for the Statements property. The value for the NextStatement property. Represents a For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). This node is associated with the following syntax kinds: The For Each statement that begins the block. Returns a copy of this with the ForEachStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. The statements contained in the For or For Each loop. This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the NextStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ForEachStatement property. The value for the Statements property. The value for the NextStatement property. Represents a For or For Each statement. The "For" keyword. Returns a copy of this with the ForKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. Returns a copy of this with the ControlVariable property changed to the specified value. Returns this instance if the specified value is the same as the current value. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. This node is associated with the following syntax kinds: The "For" keyword. Returns a copy of this with the ForKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. Returns a copy of this with the ControlVariable property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "=" token. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression denoting the initial value of the iteration. Returns a copy of this with the FromValue property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "To" keyword. Returns a copy of this with the ToKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression denoting the final value of the iteration. Returns a copy of this with the ToValue property changed to the specified value. Returns this instance if the specified value is the same as the current value. The optional Step clause. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the StepClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ForKeyword property. The value for the ControlVariable property. The value for the EqualsToken property. The value for the FromValue property. The value for the ToKeyword property. The value for the ToValue property. The value for the StepClause property. The Step clause in a For Statement. This node is associated with the following syntax kinds: The "Step" keyword. Returns a copy of this with the StepKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression denoting the step increment. Returns a copy of this with the StepValue property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the StepKeyword property. The value for the StepValue property. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. This node is associated with the following syntax kinds: The "For" keyword. Returns a copy of this with the ForKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Each" keyword. Returns a copy of this with the EachKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. Returns a copy of this with the ControlVariable property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "In" keyword. Returns a copy of this with the InKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression denoting the collection to iterate over. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ForKeyword property. The value for the EachKeyword property. The value for the ControlVariable property. The value for the InKeyword property. The value for the Expression property. The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. This node is associated with the following syntax kinds: The "Next" keyword. Returns a copy of this with the NextKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The variables in the Next statement, if present If nothing is present, an empty list is returned. Returns a copy of this with the ControlVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NextKeyword property. The value for the ControlVariables property. The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. This node is associated with the following syntax kinds: The "Using" keyword. Returns a copy of this with the UsingKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. If the Using statement is of a form that does not declare a new variable, this is the expression used in the using. Otherwise, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. If the Using statement is of a form that declares one or more new variables, this is the list of variable declarations. Otherwise, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Variables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the UsingKeyword property. The value for the Expression property. The value for the Variables property. Represents a Throw statement. This node is associated with the following syntax kinds: The "Throw" keyword Returns a copy of this with the ThrowKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression denoting the value being thrown. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ThrowKeyword property. The value for the Expression property. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. This node is associated with the following syntax kinds: The target (left hand side) of the assignment. Returns a copy of this with the Left property changed to the specified value. Returns this instance if the specified value is the same as the current value. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The source (right hand side) of the assignment. Returns a copy of this with the Right property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the Left property. The value for the OperatorToken property. The value for the Right property. Represents a left-hand side of a MidAssignment statement. This node is associated with the following syntax kinds: The "Mid" possibly followed by a type character. Returns a copy of this with the Mid property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument list. Returns a copy of this with the ArgumentList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Mid property. The value for the ArgumentList property. Represent a call statement (also known as a invocation statement). This node is associated with the following syntax kinds: The "Call" keyword. Returns a copy of this with the CallKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression denoting the call. This could be an Invocation or a MemberAccess (in the case where no parentheses were supplied.) Returns a copy of this with the Invocation property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the CallKeyword property. The value for the Invocation property. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. This node is associated with the following syntax kinds: The "AddHandler" or "RemoveHandler" keyword. Returns a copy of this with the AddHandlerOrRemoveHandlerKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The event being accessed. Returns a copy of this with the EventExpression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The delegate being added or removed. Returns a copy of this with the DelegateExpression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AddHandlerOrRemoveHandlerKeyword property. The value for the EventExpression property. The value for the CommaToken property. The value for the DelegateExpression property. Represent a RaiseEvent statement. This node is associated with the following syntax kinds: The "RaiseEvent" keyword Returns a copy of this with the RaiseEventKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the event being raised. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument list, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ArgumentList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the RaiseEventKeyword property. The value for the Name property. The value for the ArgumentList property. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. This node is associated with the following syntax kinds: The "With" keyword. Returns a copy of this with the WithKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression that is the operand of the With statement. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WithKeyword property. The value for the Expression property. Represents a ReDim statement. This node is associated with the following syntax kinds: The "ReDim" keyword. Returns a copy of this with the ReDimKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the PreserveKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of ReDim clauses. Returns a copy of this with the Clauses property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the ReDimKeyword property. The value for the PreserveKeyword property. The value for the Clauses property. Represents a ReDim statement clause. This node is associated with the following syntax kinds: The target of the ReDim statement. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ArraySizeInitializationModifier. Returns a copy of this with the ArrayBounds property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Expression property. The value for the ArrayBounds property. Represents an "Erase" statement. This node is associated with the following syntax kinds: The "Erase" keyword. Returns a copy of this with the EraseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of expressions denoting the arrays to erase. Returns a copy of this with the Expressions property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the EraseKeyword property. The value for the Expressions property. An abstract base class for all node classes that define expressions. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. This node is associated with the following syntax kinds: The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Returns a copy of this with the Token property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the Token property. Represents a parenthesized expression. This node is associated with the following syntax kinds: The "(" token Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression inside the parentheses. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the Expression property. The value for the CloseParenToken property. Represents a tuple literal expression. This node is associated with the following syntax kinds: The "(" token Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of tuple arguments. Returns a copy of this with the Arguments property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the Arguments property. The value for the CloseParenToken property. Represents a tuple type expression. This node is associated with the following syntax kinds: The "(" token Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of tuple elements. Returns a copy of this with the Elements property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the Elements property. The value for the CloseParenToken property. Represents a single declaration of a tuple element. Represents a single declaration of a tuple element supplying only the type. This node is associated with the following syntax kinds: The type-name part of the tuple element syntax. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Type property. Represents a single declaration of a tuple element supplying element name and optionally a type. This node is associated with the following syntax kinds: The name of the element. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. A simple "As" clause specifying the type of the tuple element. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. The value for the AsClause property. Identifies one of the special instances "Me", "MyClass" or "MyBase". The Kind property identifies which. The "Me", "MyClass" or "MyBase" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Identifies the special instance "Me" This node is associated with the following syntax kinds: The "Me", "MyClass" or "MyBase" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. Identifies the special instance "MyBase" This node is associated with the following syntax kinds: The "Me", "MyClass" or "MyBase" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. Identifies the special instance "MyClass" This node is associated with the following syntax kinds: The "Me", "MyClass" or "MyBase" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. Represents a GetType expression. This node is associated with the following syntax kinds: The "GetType" keyword. Returns a copy of this with the GetTypeKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type to get the Type object for. This can be an open generic type. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GetTypeKeyword property. The value for the OpenParenToken property. The value for the Type property. The value for the CloseParenToken property. Represents a TypeOf...Is or IsNot expression. This node is associated with the following syntax kinds: The "TypeOf" keyword. Returns a copy of this with the TypeOfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being tested. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Is" or "IsNot" keyword. Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the type being tested against. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the TypeOfKeyword property. The value for the Expression property. The value for the OperatorToken property. The value for the Type property. Represents a GetXmlNamespace expression. This node is associated with the following syntax kinds: The "GetXmlNamespace" keyword. Returns a copy of this with the GetXmlNamespaceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The Xml namespace name being referenced. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GetXmlNamespaceKeyword property. The value for the OpenParenToken property. The value for the Name property. The value for the CloseParenToken property. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. This node is associated with the following syntax kinds: The expression on the left-hand-side of the "." or "!" token. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "." or "!" token. Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The identifier after the "." or "!" token. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the Expression property. The value for the OperatorToken property. The value for the Name property. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. This node is associated with the following syntax kinds: The expression on the left-hand-side of the ".", ".@" or "..." . This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Base property changed to the specified value. Returns this instance if the specified value is the same as the current value. The initial dot "." part of the separator. Returns a copy of this with the Token1 property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "@" part of .@ or the second "." of "...". This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Token2 property changed to the specified value. Returns this instance if the specified value is the same as the current value. The third "." in a "..." separator. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Token3 property changed to the specified value. Returns this instance if the specified value is the same as the current value. The identifier after the ".", ".@" or "..." Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the Base property. The value for the Token1 property. The value for the Token2 property. The value for the Token3 property. The value for the Name property. Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. This node is associated with the following syntax kinds: The target of the call or index expression. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument list. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ArgumentList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Expression property. The value for the ArgumentList property. Base class for object, array and anonymous object creation expressions The "New" keyword. Returns a copy of this with the NewKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. This node is associated with the following syntax kinds: The "New" keyword. Returns a copy of this with the NewKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type of the object being initialized. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument list, if present. If no argument list was supplied, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ArgumentList property changed to the specified value. Returns this instance if the specified value is the same as the current value. An optional From or With clause to initialize the new object. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NewKeyword property. The value for the AttributeLists property. The value for the Type property. The value for the ArgumentList property. The value for the Initializer property. Represents a New expression that create an object of anonymous type. This node is associated with the following syntax kinds: The "New" keyword. Returns a copy of this with the NewKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. The With clause to initialize the new object. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NewKeyword property. The value for the AttributeLists property. The value for the Initializer property. Represents an expression that creates a new array. This node is associated with the following syntax kinds: The "New" keyword. Returns a copy of this with the NewKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. The element type of the array being created. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ArrayBounds property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of array modifiers such as "()" or "(,)". If no array modifiers were present, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the RankSpecifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The initializer including the braces. Returns a copy of this with the Initializer property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NewKeyword property. The value for the AttributeLists property. The value for the Type property. The value for the ArrayBounds property. The value for the RankSpecifiers property. The value for the Initializer property. Represents an expression that creates a new array without naming the element type. This node is associated with the following syntax kinds: The "{" token. Returns a copy of this with the OpenBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of initializers between the braces. If nothing is present, an empty list is returned. Returns a copy of this with the Initializers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "}" token. Returns a copy of this with the CloseBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenBraceToken property. The value for the Initializers property. The value for the CloseBraceToken property. Represents a CType, DirectCast or TryCast conversion expression. The Kind property determines which kind of cast it is. The "CType", "DirectCast" or "TryCast" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being cast. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type the expression is being cast to. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. This node is associated with the following syntax kinds: The "CType", "DirectCast" or "TryCast" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being cast. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type the expression is being cast to. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. The value for the OpenParenToken property. The value for the Expression property. The value for the CommaToken property. The value for the Type property. The value for the CloseParenToken property. This node is associated with the following syntax kinds: The "CType", "DirectCast" or "TryCast" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being cast. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type the expression is being cast to. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. The value for the OpenParenToken property. The value for the Expression property. The value for the CommaToken property. The value for the Type property. The value for the CloseParenToken property. This node is associated with the following syntax kinds: The "CType", "DirectCast" or "TryCast" keyword. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being cast. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The type the expression is being cast to. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. The value for the OpenParenToken property. The value for the Expression property. The value for the CommaToken property. The value for the Type property. The value for the CloseParenToken property. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. This node is associated with the following syntax kinds: The keyword that was used in the cast operation. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being cast. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. The value for the OpenParenToken property. The value for the Expression property. The value for the CloseParenToken property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. This node is associated with the following syntax kinds: The left operand. Returns a copy of this with the Left property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The right operand. Returns a copy of this with the Right property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the Left property. The value for the OperatorToken property. The value for the Right property. Describes a unary operator: Plus, Negate, Not or AddressOf. This node is associated with the following syntax kinds: The token that is the operator. Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being operated on. Returns a copy of this with the Operand property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the OperatorToken property. The value for the Operand property. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). This node is associated with the following syntax kinds: The "If" keyword Returns a copy of this with the IfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The first expression inside the parentheses. Returns a copy of this with the FirstExpression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The second expression inside the parentheses. Returns a copy of this with the SecondExpression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the IfKeyword property. The value for the OpenParenToken property. The value for the FirstExpression property. The value for the CommaToken property. The value for the SecondExpression property. The value for the CloseParenToken property. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). This node is associated with the following syntax kinds: The "If" keyword Returns a copy of this with the IfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The first expression inside the parentheses. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the FirstCommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The second expression inside the parentheses. Returns a copy of this with the WhenTrue property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "," token. Returns a copy of this with the SecondCommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The second expression inside the parentheses. Returns a copy of this with the WhenFalse property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the IfKeyword property. The value for the OpenParenToken property. The value for the Condition property. The value for the FirstCommaToken property. The value for the WhenTrue property. The value for the SecondCommaToken property. The value for the WhenFalse property. The value for the CloseParenToken property. Represents a lambda expression, either single line or multi-line. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Returns a copy of this with the SubOrFunctionHeader property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents a single line lambda expression. This node is associated with the following syntax kinds: The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Returns a copy of this with the SubOrFunctionHeader property changed to the specified value. Returns this instance if the specified value is the same as the current value. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Returns a copy of this with the Body property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the SubOrFunctionHeader property. The value for the Body property. Single line subs only have a single statement. However, when binding it is convenient to have a statement list. For example, dim statements are not valid in a single line lambda. However, it is nice to be able to provide semantic info about the local. The only way to create locals is to have a statement list. This method is friend because the statement list should not be part of the public api. Represents a multi-line lambda expression. This node is associated with the following syntax kinds: The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Returns a copy of this with the SubOrFunctionHeader property changed to the specified value. Returns this instance if the specified value is the same as the current value. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. If nothing is present, an empty list is returned. Returns a copy of this with the Statements property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Returns a copy of this with the EndSubOrFunctionStatement property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the SubOrFunctionHeader property. The value for the Statements property. The value for the EndSubOrFunctionStatement property. Represents the header part of a lambda expression This node is associated with the following syntax kinds: A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. If nothing is present, an empty list is returned. Returns a copy of this with the AttributeLists property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If nothing is present, an empty list is returned. Returns a copy of this with the Modifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Sub" or "Function" keyword that introduces this lambda expression. Returns a copy of this with the SubOrFunctionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ParameterList property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the AttributeLists property. The value for the Modifiers property. The value for the SubOrFunctionKeyword property. The value for the ParameterList property. The value for the AsClause property. Represents a parenthesized argument list. This node is associated with the following syntax kinds: The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of arguments. This may be empty. Omitted argument are represented by an OmittedArgumentSyntax node. If nothing is present, an empty list is returned. Returns a copy of this with the Arguments property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the Arguments property. The value for the CloseParenToken property. Base class for the possible kinds of arguments that can appear in an argument list. Gets a value indicating whether this argument is a named argument. True if this argument is a named argument; otherwise false. Gets a value indicating whether this argument is an omitted argument. True if this argument is an omitted argument; otherwise false. Gets the expression of this argument, if any. The expression of this argument if it is a simple argument; otherwise null. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. This node is associated with the following syntax kinds: An empty token because all non terminals must have a token. Returns a copy of this with the Empty property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Empty property. Represents an argument that is just an optional argument name and an expression. This node is associated with the following syntax kinds: The optional name and ":=" prefix of a named argument. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the NameColonEquals property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression that is the argument. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NameColonEquals property. The value for the Expression property. Represents an identifier name followed by a ":=" token in a named argument. This node is associated with the following syntax kinds: The name used to identify the named argument. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ":=" token. Returns a copy of this with the ColonEqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the ColonEqualsToken property. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. This node is associated with the following syntax kinds: The lower bound of the range. This is typically the integer constant zero. Returns a copy of this with the LowerBound property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "To" keyword. Returns a copy of this with the ToKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The upper bound of the range. Returns a copy of this with the UpperBound property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LowerBound property. The value for the ToKeyword property. The value for the UpperBound property. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. This node is associated with the following syntax kinds: A list of all the query operators in this query expression. This list always contains at least one operator. Returns a copy of this with the Clauses property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Clauses property. This is a base class for all query operators. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. This node is associated with the following syntax kinds: The name of the range variable being defined. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Describes the type of the variable being defined. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "In" keyword. Returns a copy of this with the InKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression that serves as the source of items for the range variable. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. The value for the AsClause property. The value for the InKeyword property. The value for the Expression property. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. This node is associated with the following syntax kinds: The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the expression. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the NameEquals property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression used to initialize the expression variable. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NameEquals property. The value for the Expression property. Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. This node is associated with the following syntax kinds: The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the aggregation expression. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the NameEquals property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the aggregation function. The "Group" aggregation function is represented by the identifier "Group". Returns a copy of this with the Aggregation property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NameEquals property. The value for the Aggregation property. Represents the name and optional type of an expression range variable. This node is associated with the following syntax kinds: The name of the variable being defined. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Describes the type of the variable being defined. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "=" token. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. The value for the AsClause property. The value for the EqualsToken property. Represents aggregation in aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. This node is associated with the following syntax kinds: The name of the aggregation function. Returns a copy of this with the FunctionName property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument to the aggregation function. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Argument property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token, if present. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the FunctionName property. The value for the OpenParenToken property. The value for the Argument property. The value for the CloseParenToken property. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. This node is associated with the following syntax kinds: The "Group" keyword. Returns a copy of this with the GroupKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GroupKeyword property. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. This node is associated with the following syntax kinds: The "From" keyword. Returns a copy of this with the FromKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of collection variables declared by this From operator. Returns a copy of this with the Variables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the FromKeyword property. The value for the Variables property. Represents a "Let" query operator. This node is associated with the following syntax kinds: The "Let" keyword. Returns a copy of this with the LetKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of expression range variable being defined by the Let operator. Returns a copy of this with the Variables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LetKeyword property. The value for the Variables property. Represents an Aggregate query operator. This node is associated with the following syntax kinds: The "Aggregate" keyword. Returns a copy of this with the AggregateKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of collection range variables declared by this Aggregate operator. Returns a copy of this with the Variables property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of additional query operators. It may be empty. If nothing is present, an empty list is returned. Returns a copy of this with the AdditionalQueryOperators property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Into" keyword. Returns a copy of this with the IntoKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of new variables being defined by the aggregation. Returns a copy of this with the AggregationVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AggregateKeyword property. The value for the Variables property. The value for the AdditionalQueryOperators property. The value for the IntoKeyword property. The value for the AggregationVariables property. Represents the "Distinct" query operator. This node is associated with the following syntax kinds: The "Distinct" keyword. Returns a copy of this with the DistinctKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the DistinctKeyword property. Represents a "Where" query operator. This node is associated with the following syntax kinds: The "Where" keyword. Returns a copy of this with the WhereKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The boolean expression used for filtering. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the WhereKeyword property. The value for the Condition property. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. This node is associated with the following syntax kinds: The "Skip" or "Take" keyword. Returns a copy of this with the SkipOrTakeKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "While" keyword. Returns a copy of this with the WhileKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The boolean expression used for partitioning. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the SkipOrTakeKeyword property. The value for the WhileKeyword property. The value for the Condition property. Represents a "Skip" or "Take" query operator. The Kind property tells which. This node is associated with the following syntax kinds: The "Skip" or "Take" keyword. Returns a copy of this with the SkipOrTakeKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the expression with the number of items to take or skip. Returns a copy of this with the Count property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the SkipOrTakeKeyword property. The value for the Count property. Represents the "Group By" query operator. This node is associated with the following syntax kinds: The "Group" keyword. Returns a copy of this with the GroupKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The optional list of variables being grouped; the contents of the Group clause. If none were specified, an empty list is returned. If nothing is present, an empty list is returned. Returns a copy of this with the Items property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "By" keyword. Returns a copy of this with the ByKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The key values being used for grouping. Returns a copy of this with the Keys property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the IntoKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of new variables that calculate aggregations. Returns a copy of this with the AggregationVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GroupKeyword property. The value for the Items property. The value for the ByKeyword property. The value for the Keys property. The value for the IntoKeyword property. The value for the AggregationVariables property. Represents a Join or a Group Join query operator. The "Join" keyword. Returns a copy of this with the JoinKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Defines the collection range variables being joined to. Returns a copy of this with the JoinedVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. An additional Join or Group Join query operator. If nothing is present, an empty list is returned. Returns a copy of this with the AdditionalJoins property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "On" keyword. Returns a copy of this with the OnKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Returns a copy of this with the JoinConditions property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the "expression Equals expression" condition in a Join. This node is associated with the following syntax kinds: The left expression in the Join condition. Returns a copy of this with the Left property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Equals" keyword. Returns a copy of this with the EqualsKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The right expression in the Join condition. Returns a copy of this with the Right property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Left property. The value for the EqualsKeyword property. The value for the Right property. Represents a Join query operator. This node is associated with the following syntax kinds: The "Join" keyword. Returns a copy of this with the JoinKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Defines the collection range variables being joined to. Returns a copy of this with the JoinedVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. An additional Join or Group Join query operator. If nothing is present, an empty list is returned. Returns a copy of this with the AdditionalJoins property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "On" keyword. Returns a copy of this with the OnKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Returns a copy of this with the JoinConditions property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the JoinKeyword property. The value for the JoinedVariables property. The value for the AdditionalJoins property. The value for the OnKeyword property. The value for the JoinConditions property. Represents the "Group Join" query operator. This node is associated with the following syntax kinds: The "Group" keyword. Returns a copy of this with the GroupKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Join" keyword. Returns a copy of this with the JoinKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Defines the collection range variables being joined to. Returns a copy of this with the JoinedVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. An additional Join or Group Join query operator. If nothing is present, an empty list is returned. Returns a copy of this with the AdditionalJoins property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "On" keyword. Returns a copy of this with the OnKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Returns a copy of this with the JoinConditions property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Into" keyword. Returns a copy of this with the IntoKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of new variables that calculate aggregations. Returns a copy of this with the AggregationVariables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GroupKeyword property. The value for the JoinKeyword property. The value for the JoinedVariables property. The value for the AdditionalJoins property. The value for the OnKeyword property. The value for the JoinConditions property. The value for the IntoKeyword property. The value for the AggregationVariables property. Represents the "Order By" query operator. This node is associated with the following syntax kinds: The "Order" keyword Returns a copy of this with the OrderKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "By" keyword. Returns a copy of this with the ByKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of OrderExpression's to sort by. Returns a copy of this with the Orderings property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OrderKeyword property. The value for the ByKeyword property. The value for the Orderings property. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. This node is associated with the following syntax kinds: The expression to sort by. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AscendingOrDescendingKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the Expression property. The value for the AscendingOrDescendingKeyword property. Represents the "Select" query operator. This node is associated with the following syntax kinds: The "Select" keyword. Returns a copy of this with the SelectKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The list of expression range variables being defined by the Select query operator. Returns a copy of this with the Variables property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the SelectKeyword property. The value for the Variables property. This is the base class for all XML expression syntax nodes (XmlDocument and XmlElement). Represents an XML Document literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the Declaration property changed to the specified value. Returns this instance if the specified value is the same as the current value. If nothing is present, an empty list is returned. Returns a copy of this with the PrecedingMisc property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Root property changed to the specified value. Returns this instance if the specified value is the same as the current value. If nothing is present, an empty list is returned. Returns a copy of this with the FollowingMisc property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Declaration property. The value for the PrecedingMisc property. The value for the Root property. The value for the FollowingMisc property. Represents the XML declaration prologue in an XML literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanQuestionToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the XmlKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Version property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Encoding property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Standalone property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the QuestionGreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanQuestionToken property. The value for the XmlKeyword property. The value for the Version property. The value for the Encoding property. The value for the Standalone property. The value for the QuestionGreaterThanToken property. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Equals property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the Equals property. The value for the Value property. Represents an XML element with content in an XML literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the StartTag property changed to the specified value. Returns this instance if the specified value is the same as the current value. If nothing is present, an empty list is returned. Returns a copy of this with the Content property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndTag property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the StartTag property. The value for the Content property. The value for the EndTag property. Represents Xml text. This node is associated with the following syntax kinds: A list of all the text tokens in the Xml text. This list always contains at least one token. Returns a copy of this with the TextTokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the TextTokens property. Represents the start tag of an XML element of the form <element>. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. If nothing is present, an empty list is returned. Returns a copy of this with the Attributes property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the GreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanToken property. The value for the Name property. The value for the Attributes property. The value for the GreaterThanToken property. Represents the end tag of an XML element of the form </element>. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanSlashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the GreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanSlashToken property. The value for the Name property. The value for the GreaterThanToken property. Represents an empty XML element of the form <element /> This node is associated with the following syntax kinds: Returns a copy of this with the LessThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. If nothing is present, an empty list is returned. Returns a copy of this with the Attributes property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the SlashGreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanToken property. The value for the Name property. The value for the Attributes property. The value for the SlashGreaterThanToken property. Represents an XML attribute in an XML literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the EqualsToken property. The value for the Value property. Represents an XML attribute in an XML literal expression. Represents a string of XML characters embedded as the content of an XML element. This node is associated with the following syntax kinds: Returns a copy of this with the StartQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. If nothing is present, an empty list is returned. Returns a copy of this with the TextTokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the StartQuoteToken property. The value for the TextTokens property. The value for the EndQuoteToken property. Represents an XML name of the form 'name' appearing in GetXmlNamespace(). This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. This node is associated with the following syntax kinds: This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Prefix property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the LocalName property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Prefix property. The value for the LocalName property. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the GreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanToken property. The value for the Name property. The value for the GreaterThanToken property. Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ColonToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the ColonToken property. Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanExclamationMinusMinusToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the TextTokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the MinusMinusGreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanExclamationMinusMinusToken property. The value for the TextTokens property. The value for the MinusMinusGreaterThanToken property. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanQuestionToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the TextTokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the QuestionGreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanQuestionToken property. The value for the Name property. The value for the TextTokens property. The value for the QuestionGreaterThanToken property. Represents an XML CDATA section in an XML literal expression. This node is associated with the following syntax kinds: Returns a copy of this with the BeginCDataToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the TextTokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndCDataToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the BeginCDataToken property. The value for the TextTokens property. The value for the EndCDataToken property. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. This node is associated with the following syntax kinds: Returns a copy of this with the LessThanPercentEqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the PercentGreaterThanToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the LessThanPercentEqualsToken property. The value for the Expression property. The value for the PercentGreaterThanToken property. Abstract node class that represents the textual description of a type, possibly include generic type arguments, qualified names, array specifiers, nullable specifier and the like. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. This node is associated with the following syntax kinds: The type of the elements of the array. Returns a copy of this with the ElementType property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents the list of "()" or "(,,)" modifiers on the array type. Returns a copy of this with the RankSpecifiers property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElementType property. The value for the RankSpecifiers property. A type name that represents a nullable type, such as "Integer?". This node is associated with the following syntax kinds: The kind of type that is this type is a nullable of. Cannot be an array type or a nullable type. Returns a copy of this with the ElementType property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "?" token. Returns a copy of this with the QuestionMarkToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ElementType property. The value for the QuestionMarkToken property. Represents an occurrence of a Visual Basic built-in type such as Integer or String in source code. This node is associated with the following syntax kinds: The keyword that was used to describe the built-in type. Returns a copy of this with the Keyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Keyword property. Abstract node class that represents a name, possibly include generic arguments and qualified names. Abstract node class that represents a name, possibly include generic arguments. The identifier in the name. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents a type name consisting of a single identifier (which might include brackets or a type character). This node is associated with the following syntax kinds: The identifier in the name. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). This node is associated with the following syntax kinds: The identifier in the name. Returns a copy of this with the Identifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. The generic argument list. Returns a copy of this with the TypeArgumentList property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Identifier property. The value for the TypeArgumentList property. Represents a qualified type name, for example X.Y or X(Of Z).Y. This node is associated with the following syntax kinds: The part of the name that appears to the left of the dot. This can itself be any name. Returns a copy of this with the Left property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "." token that separates the names. Returns a copy of this with the DotToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The part of the name that appears to the right of the dot. This must be a simple identifier. Returns a copy of this with the Right property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Left property. The value for the DotToken property. The value for the Right property. Represents a name in the global namespace. This node is associated with the following syntax kinds: The "Global" keyword. Returns a copy of this with the GlobalKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the GlobalKeyword property. Represents a parenthesized list of generic type arguments. This node is associated with the following syntax kinds: The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Of" keyword. Returns a copy of this with the OfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. A list of all the type arguments. Returns a copy of this with the Arguments property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the OfKeyword property. The value for the Arguments property. The value for the CloseParenToken property. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Signature property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AsClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the Signature property. The value for the AsClause property. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. This node is associated with the following syntax kinds: Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ArgumentTypes property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenParenToken property. The value for the ArgumentTypes property. The value for the CloseParenToken property. This node is associated with the following syntax kinds: This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Modifier property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Type property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Modifier property. The value for the Type property. This node is associated with the following syntax kinds: Returns a copy of this with the OperatorKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the OperatorToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OperatorKeyword property. The value for the OperatorToken property. This node is associated with the following syntax kinds: Returns a copy of this with the Left property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the DotToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Right property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Left property. The value for the DotToken property. The value for the Right property. Represent a Yield statement. This node is associated with the following syntax kinds: The "Yield" keyword. Returns a copy of this with the YieldKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression whose value is being yielded. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the YieldKeyword property. The value for the Expression property. Represents an Await expression. This node is associated with the following syntax kinds: The "Await" keyword. Returns a copy of this with the AwaitKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression being awaited. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the AwaitKeyword property. The value for the Expression property. Abstract class that represent structured trivia. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. This node is associated with the following syntax kinds: The list of tokens that were skipped by the parser. If nothing is present, an empty list is returned. Returns a copy of this with the Tokens property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Tokens property. Represents a documentation comment e.g. ''' <Summary> appearing in source. This node is associated with the following syntax kinds: If nothing is present, an empty list is returned. Returns a copy of this with the Content property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Content property. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the StartQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Reference property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the EqualsToken property. The value for the StartQuoteToken property. The value for the Reference property. The value for the EndQuoteToken property. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. This node is associated with the following syntax kinds: Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the StartQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Reference property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Name property. The value for the EqualsToken property. The value for the StartQuoteToken property. The value for the Reference property. The value for the EndQuoteToken property. ExpressionSyntax node representing the object conditionally accessed. This node is associated with the following syntax kinds: The expression on the left-hand-side of the "?". This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. "?" token. Returns a copy of this with the QuestionMarkToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. ExpressionSyntax node representing the access expression to be executed when the object is not null." Returns a copy of this with the WhenNotNull property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the Expression property. The value for the QuestionMarkToken property. The value for the WhenNotNull property. Represents a NameOf expression. This node is associated with the following syntax kinds: The "NameOf" keyword. Returns a copy of this with the NameOfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "(" token. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The argument. Returns a copy of this with the Argument property changed to the specified value. Returns this instance if the specified value is the same as the current value. The ")" token. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the NameOfKeyword property. The value for the OpenParenToken property. The value for the Argument property. The value for the CloseParenToken property. Represents an interpolated string expression. This node is associated with the following syntax kinds: The opening '$"', '$“', or '$”' token. Returns a copy of this with the DollarSignDoubleQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The contents of the interpolated string. Returns a copy of this with the Contents property changed to the specified value. Returns this instance if the specified value is the same as the current value. The closing '"', '”', or '“' token. Returns a copy of this with the DoubleQuoteToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the DollarSignDoubleQuoteToken property. The value for the Contents property. The value for the DoubleQuoteToken property. Represents either text content or an interpolation. Represents literal text content in an interpolated string. This node is associated with the following syntax kinds: The text token. Returns a copy of this with the TextToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the TextToken property. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. This node is associated with the following syntax kinds: The opening curly brace '{' token. Returns a copy of this with the OpenBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The expression whose formatted value should be embedded in the resultant string. Returns a copy of this with the Expression property changed to the specified value. Returns this instance if the specified value is the same as the current value. Optional. The alignment clause ',alignment' of the embedded expression. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the AlignmentClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. Optional. The format string clause ':formatString' of the embedded expression. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the FormatClause property changed to the specified value. Returns this instance if the specified value is the same as the current value. The closing curly brace '}' token of the embedded expression. Returns a copy of this with the CloseBraceToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the OpenBraceToken property. The value for the Expression property. The value for the AlignmentClause property. The value for the FormatClause property. The value for the CloseBraceToken property. Represents an alignment clause ',alignment' of an interpolated string embedded expression. This node is associated with the following syntax kinds: The comma ',' token. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. An expression representing the alignment of the interpolated expression. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the CommaToken property. The value for the Value property. Represents a format string clause ':formatString' of an interpolated string embedded expression. This node is associated with the following syntax kinds: The ':' token. Returns a copy of this with the ColonToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The format string. Returns a copy of this with the FormatStringToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the ColonToken property. The value for the FormatStringToken property. Represents a pre-processing directive (such as #If, #Const or #Region) appearing in source. The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Represents a #Const pre-processing constant declaration appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Const" keyword. Returns a copy of this with the ConstKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The name of the pre-processing constant being defined. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "=" token. Returns a copy of this with the EqualsToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. An expression representing the value of the pre-processing constant being defined. Returns a copy of this with the Value property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the ConstKeyword property. The value for the Name property. The value for the EqualsToken property. The value for the Value property. Represents the beginning of an #If pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ElseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the IfOrElseIfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Condition property changed to the specified value. Returns this instance if the specified value is the same as the current value. This child is optional. If it is not present, then Nothing is returned. Returns a copy of this with the ThenKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The new kind. The value for the HashToken property. The value for the ElseKeyword property. The value for the IfOrElseIfKeyword property. The value for the Condition property. The value for the ThenKeyword property. Represents an #Else pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ElseKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the ElseKeyword property. Represents an #End If pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the IfKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the EndKeyword property. The value for the IfKeyword property. Represents the beginning of a #Region directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Region" keyword. Returns a copy of this with the RegionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The label of the code region being defined. Returns a copy of this with the Name property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the RegionKeyword property. The value for the Name property. Represents an #End Region directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "End" keyword. Returns a copy of this with the EndKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. The "Region" keyword. Returns a copy of this with the RegionKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the EndKeyword property. The value for the RegionKeyword property. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ExternalSourceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ExternalSource property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the CommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the LineStart property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the ExternalSourceKeyword property. The value for the OpenParenToken property. The value for the ExternalSource property. The value for the CommaToken property. The value for the LineStart property. The value for the CloseParenToken property. Represents an #End ExternalSource pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EndKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ExternalSourceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the EndKeyword property. The value for the ExternalSourceKeyword property. Represents an #ExternalChecksum pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ExternalChecksumKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the OpenParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ExternalSource property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the FirstCommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Guid property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the SecondCommaToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the Checksum property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the CloseParenToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the ExternalChecksumKeyword property. The value for the OpenParenToken property. The value for the ExternalSource property. The value for the FirstCommaToken property. The value for the Guid property. The value for the SecondCommaToken property. The value for the Checksum property. The value for the CloseParenToken property. Represents #Enable Warning pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the EnableKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the WarningKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ErrorCodes property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the EnableKeyword property. The value for the WarningKeyword property. The value for the ErrorCodes property. Represents #Disable Warning pre-processing directive appearing in source. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the DisableKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the WarningKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ErrorCodes property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the DisableKeyword property. The value for the WarningKeyword property. The value for the ErrorCodes property. Represents an #r directive appearing in scripts. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the ReferenceKeyword property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the File property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. The value for the ReferenceKeyword property. The value for the File property. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. This node is associated with the following syntax kinds: The "#" token in a preprocessor directive. Returns a copy of this with the HashToken property changed to the specified value. Returns this instance if the specified value is the same as the current value. Returns a copy of this with the specified changes. Returns this instance if there are no actual changes. The value for the HashToken property. Creates a syntax trivia normalizing visitor The whitespace to indent with The whitespace to use for end of line Whether to use elastic trivia or not Whether to rewrite keywords in default casing or not indentation depth is the declaration depth for statements within the block. for start/end statements of these blocks (e.g. the if statement), it is a level less We each element of option, imports and attributes on a separate line, where the last element of this the list if followed by an empty line: Option Strict On Imports System Imports Goo [...] Namespace [...] Add an empty line after the begin, except the first member is a nested namespace. Separate each member of a namespace with an empty line. We want to display type blocks (Modules, Classes, Structures and Interfaces) like follows Class Goo implements IBar1, IBar2 implements IBar3 inherits Bar1 Public Sub Boo() End Sub End Class or Class Goo Public Sub Boo() End Sub End Class Basically it's an empty line between implements and inherits and between each member. If there are no inherits or implements, add an empty line before the first member. Each statement and the begin will be displayed on a separate line. No empty lines. Adds VB specific parts to the line directive map Represents a visitor that visits only the single SyntaxNode passed into its method and produces a value of the type specified by the parameter. The type of the return value of this visitor's Visit method. Represents a visitor that visits only the single SyntaxNode passed into its method. Represents a which descends an entire graph and may replace or remove visited SyntaxNodes in depth-first order. A class to represent an empty statement. This can occur when a colon is on a line without anything else. An empty token because all non terminals must have a token. A class to represent an empty statement. This can occur when a colon is on a line without anything else. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. A representing the specific kind of EndBlockStatementSyntax. One of EndIfStatement, EndUsingStatement, EndWithStatement, EndSelectStatement, EndStructureStatement, EndEnumStatement, EndInterfaceStatement, EndClassStatement, EndModuleStatement, EndNamespaceStatement, EndSubStatement, EndFunctionStatement, EndGetStatement, EndSetStatement, EndPropertyStatement, EndOperatorStatement, EndEventStatement, EndAddHandlerStatement, EndRemoveHandlerStatement, EndRaiseEventStatement, EndWhileStatement, EndTryStatement, EndSyncLockStatement. The "End" keyword The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an "End XXX" statement, where XXX is a single keyword. A representing the specific kind of EndBlockStatementSyntax. One of EndIfStatement, EndUsingStatement, EndWithStatement, EndSelectStatement, EndStructureStatement, EndEnumStatement, EndInterfaceStatement, EndClassStatement, EndModuleStatement, EndNamespaceStatement, EndSubStatement, EndFunctionStatement, EndGetStatement, EndSetStatement, EndPropertyStatement, EndOperatorStatement, EndEventStatement, EndAddHandlerStatement, EndRemoveHandlerStatement, EndRaiseEventStatement, EndWhileStatement, EndTryStatement, EndSyncLockStatement. The keyword that ends the block. Must be one of: "If", "Using", "With", "Select", "Structure", "Enum", "Interface", "Class", "Module", "Namespace", "Sub", "Function", "Get, "Set", "Property", "Operator", "Event", "AddHandler", "RemoveHandler", "RaiseEvent", "While", "Try" or "SyncLock". Represents an entire source file of VB code. Represents the list of Option statements at the beginning of a source file. Represents the list of Imports statements at the beginning of a source file. Represents the list of AttributeStatements at the beginning of a source file that contain the Assembly and Module attributes. Represents the members of the default namespace for this source file: all the top-level type and namespace declarations in the file. May also contain Statements that are not valid Represents the end of the source file. This token may have trivia (whitespace, comments, ...) attached to it. Represents an entire source file of VB code. Represents the list of Option statements at the beginning of a source file. Represents the list of Imports statements at the beginning of a source file. Represents the list of AttributeStatements at the beginning of a source file that contain the Assembly and Module attributes. Represents the members of the default namespace for this source file: all the top-level type and namespace declarations in the file. May also contain Statements that are not valid Represents an entire source file of VB code. Represents an Option statement, such as "Option Strict On". The "Option" keyword. The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. The keyword that identifiers the value being set for the option: On, Off, Text or Binary. Represents an Option statement, such as "Option Strict On". The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. The keyword that identifiers the value being set for the option: On, Off, Text or Binary. Represents an Option statement, such as "Option Strict On". The keyword that identifies the option being set: Explicit, Strict, Compare or Infer. Represents an Imports statement, which has one or more imports clauses. The "Imports" keyword. A list of one or more import clauses. Each clause is either an alias, namespace or XML namespace import. Represents an Imports statement, which has one or more imports clauses. A list of one or more import clauses. Each clause is either an alias, namespace or XML namespace import. Represents an Imports statement, which has one or more imports clauses. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. An optional alias for the namespace or type being imported. The namespace or type being imported. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. The namespace or type being imported. Represents an alias identifier followed by an "=" token in an Imports clause. The identifier being introduced. The "=" token. Represents an alias identifier followed by an "=" token in an Imports clause. The identifier being introduced. Represents an alias identifier followed by an "=" token in an Imports clause. The identifier being introduced. Defines a XML namespace for XML expressions. Identifies the XML namespace alias and URI. Defines a XML namespace for XML expressions. Identifies the XML namespace alias and URI. Represents a Namespace statement, its contents and the End Namespace statement. The statement that begins the NamespaceBlock. The declarations contained in the namespace statement. The End Namespace statement that ends the block. Represents a Namespace statement, its contents and the End Namespace statement. The statement that begins the NamespaceBlock. The declarations contained in the namespace statement. Represents a Namespace statement, its contents and the End Namespace statement. The statement that begins the NamespaceBlock. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. The "Namespace" keyword. A (possibly dotted) name denoting the namespace being declared. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. A (possibly dotted) name denoting the namespace being declared. Represents a declaration of Module, its contents and the End statement that ends it. The "Module" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Module" statement that ends the block. Represents a declaration of Module, its contents and the End statement that ends it. The "Module" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. Represents a declaration of Module, its contents and the End statement that ends it. The "Module" statement that begins the block. Represents a declaration of a Structure, its contents and the End statement that ends it. The "Structure" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Structure" statement that ends the block. Represents a declaration of a Structure, its contents and the End statement that ends it. The "Structure" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. Represents a declaration of a Structure, its contents and the End statement that ends it. The "Structure" statement that begins the block. Represents a declaration of a Interface, its contents and the End statement that ends it. The "Interface" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Interface" statement that ends the block. Represents a declaration of a Interface, its contents and the End statement that ends it. The "Interface" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. Represents a declaration of a Interface, its contents and the End statement that ends it. The "Interface" statement that begins the block. Represents a declaration of a Class its contents and the End statement that ends it. The "Class" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. The "End Class" statement that ends the block. Represents a declaration of a Class its contents and the End statement that ends it. The "Class" statement that begins the block. A list of the Inherits declarations for the type. A list of the Implements declarations for the type. The declarations contained in the type or module. Represents a declaration of a Class its contents and the End statement that ends it. The "Class" statement that begins the block. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. The statement that begins the type or module. The declarations contained in the enumeration. The End XXX statement that ends the block. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. The statement that begins the type or module. The declarations contained in the enumeration. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. The statement that begins the type or module. Represents an Inherits statement in a Class, Structure or Interface. The "Inherits" keyword. A list of the types being inherited. Represents an Inherits statement in a Class, Structure or Interface. A list of the types being inherited. Represents an Inherits statement in a Class, Structure or Interface. A list of the types being inherited. Represents an Implements statement in a Class or Structure. The "Implements" keyword. A list of the types being implemented. Represents an Implements statement in a Class or Structure. A list of the types being implemented. Represents an Implements statement in a Class or Structure. A list of the types being implemented. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Module" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Structure" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Interface" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Class" keyword. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The name of the type being declared. If present, a type parameter list with generic parameters for this type. If no generic parameters were present, Nothing is returned. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. The name of the type being declared. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. The name of the type being declared. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The "Enum" keyword. The name of the enum being declared. Optional "As XXX" clause describing the underlying type of the enumeration. If no As clause was specified, Nothing is returned. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The name of the enum being declared. Optional "As XXX" clause describing the underlying type of the enumeration. If no As clause was specified, Nothing is returned. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. The name of the enum being declared. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. The name of the enum being declared. Represents the type parameter list in a declaration. The "(" token. The "Of" keyword. A list of the type parameters. There must be at least one type parameter in the list. The ")" token. Represents the type parameter list in a declaration. A list of the type parameters. There must be at least one type parameter in the list. Represents the type parameter list in a declaration. A list of the type parameters. There must be at least one type parameter in the list. Represents a type parameter on a generic type declaration. Represents the "In" or "Out" variance keyword on a type parameter, if present. If no variance modifier was present, Nothing is returned. The name of the type parameter The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. Represents a type parameter on a generic type declaration. The name of the type parameter Represents a type parameter on a generic type declaration. The name of the type parameter One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". The "As" keyword, if any type constraints were supplied. If no type constraints were supplied, Nothing is returned. A list of the supplied constraints. If no constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". A list of the supplied constraints. If no constraints were supplied, Nothing is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". The "As" keyword. The "{" token. A list of the supplied constraints. If no constraints were supplied, an empty list is returned. The "}" token. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". A list of the supplied constraints. If no constraints were supplied, an empty list is returned. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". A list of the supplied constraints. If no constraints were supplied, an empty list is returned. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. A representing the specific kind of SpecialConstraintSyntax. One of NewConstraint, ClassConstraint, StructureConstraint. The "New", "Class" or "Structure" keyword that denotes the kind of special constraint. Represents a type parameter constraint that is a type. The type describing the constraint. Represents a name and value in an EnumDeclarationBlock. An optional value for the enum member. Represents a name and value in an EnumDeclarationBlock. Represents a name and value in an EnumDeclarationBlock. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub" or "Function" statement that begins the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. A representing the specific kind of MethodBlockSyntax. One of SubBlock, FunctionBlock. The "Sub" or "Function" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" or "End Function" statement that ends the block. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. A representing the specific kind of MethodBlockSyntax. One of SubBlock, FunctionBlock. The "Sub" or "Function" statement that begins the block. The "End Sub" or "End Function" statement that ends the block. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub New" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Sub" statement that ends the block declaration. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub New" statement that begins the block. The statements contained in the block statement. This might be an empty list. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Sub New" statement that begins the block. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Operator" statement that begins the block. The statements contained in the block statement. This might be an empty list. The "End Operator" statement that ends the block declaration. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Operator" statement that begins the block. The statements contained in the block statement. This might be an empty list. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. The "Operator" statement that begins the block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. A representing the specific kind of AccessorBlockSyntax. One of GetAccessorBlock, SetAccessorBlock, AddHandlerAccessorBlock, RemoveHandlerAccessorBlock, RaiseEventAccessorBlock. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The statements contained in the block statement. This might be an empty list. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. A representing the specific kind of AccessorBlockSyntax. One of GetAccessorBlock, SetAccessorBlock, AddHandlerAccessorBlock, RemoveHandlerAccessorBlock, RaiseEventAccessorBlock. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" statement that begins the accessor block. The "End Get", "End Set", "End AddHandler", "End RemoveHandler", or "End RaiseEvent" statement that ends the accessor block. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. The property declaration that begins the block. The accessor blocks contained in the property, between the Property and the End Property statements. The End Property statement that ends the block. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. The property declaration that begins the block. The accessor blocks contained in the property, between the Property and the End Property statements. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. The event declaration that begins the block. The accessor blocks contained in the custom event declaration, between the Event statement and the End Event statement. The End Event statement that ends the block. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. The event declaration that begins the block. The accessor blocks contained in the custom event declaration, between the Event statement and the End Event statement. Represents the parameter list in a method declaration. The "(" token that introduces the parameter list. If no parameter list was present, Nothing is returned. The list of parameters. If no parameter list was present, Nothing is returned. The ")" token that concludes the parameter list. If no parameter list was present, Nothing is returned. Represents the parameter list in a method declaration. The list of parameters. If no parameter list was present, Nothing is returned. Represents the parameter list in a method declaration. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The name of the method being declared. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The name of the method being declared. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The name of the method being declared. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The name of the method being declared. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A representing the specific kind of MethodStatementSyntax. One of SubStatement, FunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. If present, a type parameter list with generic type parameters for this method. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, a Handles clause indicated the events that this method handles. If present, an Implements clause indicated the interface methods that this method implements. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A representing the specific kind of MethodStatementSyntax. One of SubStatement, FunctionStatement. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A representing the specific kind of MethodStatementSyntax. One of SubStatement, FunctionStatement. The "Sub" or "Function" keyword that introduces this method declaration. The name of the method being declared. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" keyword. The "New" keyword in the constructor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If present, the keyword that defines the string translation semantics of the external method. The name of the method being declared. The string literal with the library name. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. The name of the method being declared. The string literal with the library name. A Declare statement that declares an external DLL method. The name of the method being declared. The string literal with the library name. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If present, the keyword that defines the string translation semantics of the external method. The name of the method being declared. The string literal with the library name. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. The name of the method being declared. The string literal with the library name. A Declare statement that declares an external DLL method. The name of the method being declared. The string literal with the library name. A Declare statement that declares an external DLL method. A representing the specific kind of DeclareStatementSyntax. One of DeclareSubStatement, DeclareFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Declare" keyword. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The "Lib" keyword. The string literal with the library name. If present, the "Alias" keyword. If not present, returns Nothing. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A representing the specific kind of DeclareStatementSyntax. One of DeclareSubStatement, DeclareFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. If present, the keyword that defines the string translation semantics of the external method. The "Sub" or "Function" keyword. The name of the method being declared. The string literal with the library name. The string literal with the alias. If not present, returns Nothing. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A Declare statement that declares an external DLL method. A representing the specific kind of DeclareStatementSyntax. One of DeclareSubStatement, DeclareFunctionStatement. The "Sub" or "Function" keyword. The name of the method being declared. The string literal with the library name. A Declare statement that declares an external DLL method. A representing the specific kind of DeclareStatementSyntax. One of DeclareSubStatement, DeclareFunctionStatement. The "Sub" or "Function" keyword. The name of the method being declared. The string literal with the library name. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. The name of the delegate being declared. A statement that declares a delegate type. The name of the delegate being declared. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. The name of the delegate being declared. A statement that declares a delegate type. The name of the delegate being declared. A statement that declares a delegate type. A representing the specific kind of DelegateStatementSyntax. One of DelegateSubStatement, DelegateFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Delegate" keyword. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A representing the specific kind of DelegateStatementSyntax. One of DelegateSubStatement, DelegateFunctionStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword. The name of the delegate being declared. If present, a type parameter list with generic type parameters for this delegate. If no generic type parameters were present, Nothing is returned. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares a delegate type. A representing the specific kind of DelegateStatementSyntax. One of DelegateSubStatement, DelegateFunctionStatement. The "Sub" or "Function" keyword. The name of the delegate being declared. A statement that declares a delegate type. A representing the specific kind of DelegateStatementSyntax. One of DelegateSubStatement, DelegateFunctionStatement. The "Sub" or "Function" keyword. The name of the delegate being declared. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The optional Custom keyword for custom event declarations. The "Event" keyword that introduces this event declaration. The name of the event being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an Implements clause indicates the interface methods that this method implements. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The name of the event being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an Implements clause indicates the interface methods that this method implements. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. The name of the event being declared. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. The name of the event being declared. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Operator" keyword that introduces this operator declaration. The operator being defined. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The operator being defined. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The operator being defined. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Property" keyword that introduces this property declaration. The name of the property being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the property. If present, an Implements clause indicated the interface methods that this method implements. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The name of the property being declared. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the property. If present, an Implements clause indicated the interface methods that this method implements. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. The name of the property being declared. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. The name of the property being declared. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A representing the specific kind of AccessorStatementSyntax. One of GetAccessorStatement, SetAccessorStatement, AddHandlerAccessorStatement, RemoveHandlerAccessorStatement, RaiseEventAccessorStatement. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. A representing the specific kind of AccessorStatementSyntax. One of GetAccessorStatement, SetAccessorStatement, AddHandlerAccessorStatement, RemoveHandlerAccessorStatement, RaiseEventAccessorStatement. The "Get", "Set", "AddHandler", "RemoveHandler", or "RaiseEvent" keyword that introduces this accessor declaration. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. The "Implements" keyword. The list of interface members being implemented. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. The list of interface members being implemented. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. The list of interface members being implemented. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. The "Handles" keyword. The list of event members being handled. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. The list of event members being handled. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. The list of event members being handled. Represents event container specified through special keywords "Me", "MyBase" or "MyClass".. The container of the event. This can be one of the special keywords: "Me", "MyBase" or "MyClass". Represents event container that refers to a WithEvents member. The container of the event. It is a simple identifier that refers to a WithEvents member of the containing type. Represents event container that refers to a WithEvents member. The container of the event. It is a simple identifier that refers to a WithEvents member of the containing type. Represents event container that refers to a WithEvents member's property. The container of the event. The "." token. The provider of the event. It is a property of a WithEvents member of the containing type. Represents event container that refers to a WithEvents member's property. The container of the event. The provider of the event. It is a property of a WithEvents member of the containing type. Represents a single handled event in a "Handles ..." clause. The container of the event. This can either be a simple identifier (identifying a members of the containing type) or one of the special keywords "Me", "MyBase" or "MyClass". The "." token. The event being handled. This must be a simple identifier. Represents a single handled event in a "Handles ..." clause. The container of the event. This can either be a simple identifier (identifying a members of the containing type) or one of the special keywords "Me", "MyBase" or "MyClass". The event being handled. This must be a simple identifier. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The missing identifier token for this incomplete member. Should only be used to have a location for error reporting. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) A list of all attribute lists on this declaration. If no attributes were specified, an empty list is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. The "As" clause that describes the return type, and possibly includes "New", "With" or "From". If no As clause was present, Nothing is returned. If present, an "= initial-value" clause describing the initial value of the variable or the value of the constant. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. The names of the variables being declared. Each name might have a "?" or "()" modifier(s) attached. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. The "As" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type-name part of the As clause. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type-name part of the As clause. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. The type-name part of the As clause. Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) The "As" keyword. The New expression Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) The New expression Represents a "With {...} clause used to initialize a new object's members. The "With" keyword. The "{" token. The comma-separated list of field initializers. The "}" token. Represents a "With {...} clause used to initialize a new object's members. The comma-separated list of field initializers. Represents a "With {...} clause used to initialize a new object's members. The comma-separated list of field initializers. Represents a "From {...} clause used to initialize a new collection object's elements. The "From" keyword. The initializer including the braces. Represents a "From {...} clause used to initialize a new collection object's elements. The initializer including the braces. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. The optional "Key" keyword. The value being assigned. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. The value being assigned. Represent a named field initializer in a With {...} initializer, such as ".x = expr". The optional "Key" keyword. The "." token. The name of the field being initialized. The "=" token. The value being assigned to the field. Represent a named field initializer in a With {...} initializer, such as ".x = expr". The name of the field being initialized. The value being assigned to the field. Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. The "=" token. The expression used as the initial value. Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. The expression used as the initial value. Represent a parameter to a method, property, constructor, etc. A list of all attribute lists on this parameter. If no attributes were specified, Nothing is returned. A list of the modifier tokens "ByVal", "ByRef", "Optional" or "ParamArray" that modify this parameter. The name of the parameter, including any "?" or "()" modifiers. If present, the "As type-name" clause describing the type of the parameter. If no As clause is present, Nothing is returned. If present, an initializer with the default value of the parameter. If no default value is present, Nothing is returned. Represent a parameter to a method, property, constructor, etc. The name of the parameter, including any "?" or "()" modifiers. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. The "?" token that indicates a nullable type. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". A list of array modifiers for the type. If no array modifiers were present, an empty list is returned. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. The identifier that names the item being declared. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". The "(" token. The comma tokens in the array type. There is one less comma than the rank. The ")" token. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". Represents a group of attributes within "<" and ">" brackets. The "<" token. A comma separated list of attribute declarations in this attribute list. The ">" token. Represents a group of attributes within "<" and ">" brackets. A comma separated list of attribute declarations in this attribute list. Represents a group of attributes within "<" and ">" brackets. Represents a single attribute declaration within an attribute list. Optional attribute target. Assembly|Module : The name of the attribute. The argument list, if present. If no argument list was supplied, Nothing is returned. Represents a single attribute declaration within an attribute list. The name of the attribute. Represents a single attribute declaration within an attribute list. The "Assembly" or "Module" attribute modifier, is present. If no attribute modifier is present, Nothing is returned. The ":" token, if an attribute modifier is present. If no attribute modifier is present, Nothing is returned. Represents a single attribute declaration within an attribute list. The "Assembly" or "Module" attribute modifier, is present. If no attribute modifier is present, Nothing is returned. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. The list of attribute lists. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. Represent an expression in a statement context. This may only be a invocation or await expression in standard code but may be any expression in VB Interactive code. The expression. Represent a "? expression" "Print" statement in VB Interactive code. "?" token. The expression whose value is being output. Represent a "? expression" "Print" statement in VB Interactive code. The expression whose value is being output. Represents a While...End While statement, including the While, body and End While. The While statement that begins the block. The statements contained in the While...End While. This might be an empty list. The End While statement that ends the block. Represents a While...End While statement, including the While, body and End While. The While statement that begins the block. The statements contained in the While...End While. This might be an empty list. Represents a While...End While statement, including the While, body and End While. The While statement that begins the block. Represents an entire Using...End Using statement, including the Using, body and End Using statements. The UsingStatement that begins the Using...End Using block. The statements contained in the Using...End Using block. This might be an empty list. The End Using statement that ends the block. Represents an entire Using...End Using statement, including the Using, body and End Using statements. The UsingStatement that begins the Using...End Using block. The statements contained in the Using...End Using block. This might be an empty list. Represents an entire Using...End Using statement, including the Using, body and End Using statements. The UsingStatement that begins the Using...End Using block. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. The SyncLock statement that begins the block. The statements contained in the SyncLock...End SyncLock statement. This might be an empty list. The End SyncLock statement that ends the block. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. The SyncLock statement that begins the block. The statements contained in the SyncLock...End SyncLock statement. This might be an empty list. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. The SyncLock statement that begins the block. Represents a With...End With block, include the With statement, the body of the block and the End With statement. The WithStatement that begins the With...End With block. The statements contained in the With...End With block. This might be an empty list. The End With statement that ends the block. Represents a With...End With block, include the With statement, the body of the block and the End With statement. The WithStatement that begins the With...End With block. The statements contained in the With...End With block. This might be an empty list. Represents a With...End With block, include the With statement, the body of the block and the End With statement. The WithStatement that begins the With...End With block. Represents the declaration of one or more local variables or constants. The modifier token (Static, Dim or Const) that introduces this local variable declaration. The list of variable declarator. Each declarator specifies one or more variable names along with a type and/or initializer. Represents a label statement. The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. The ":" token of the label statement. Represents a label statement. The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. Represents a label statement. The name of the label. If the label is a line number, returns an IntegerLiteral that is the line number, otherwise, returns an Identifier. Represents a "GoTo" statement. The "GoTo" keyword. The name of the label. If the label is a line number, wraps an IntegerLiteral that is the line number, otherwise, wraps an Identifier. Represents a "GoTo" statement. The name of the label. If the label is a line number, wraps an IntegerLiteral that is the line number, otherwise, wraps an Identifier. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A representing the specific kind of LabelSyntax. One of IdentifierLabel, NumericLabel, NextLabel. The label name (identifier), line number (integer literal), or next keyword token. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A representing the specific kind of LabelSyntax. One of IdentifierLabel, NumericLabel, NextLabel. The label name (identifier), line number (integer literal), or next keyword token. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. The "Stop" or "End" keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. A representing the specific kind of StopOrEndStatementSyntax. One of StopStatement, EndStatement. The "Stop" or "End" keyword. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. A representing the specific kind of ExitStatementSyntax. One of ExitDoStatement, ExitForStatement, ExitSubStatement, ExitFunctionStatement, ExitOperatorStatement, ExitPropertyStatement, ExitTryStatement, ExitSelectStatement, ExitWhileStatement. The "Exit" keyword. The keyword describing the block to exit. An exit statement. The kind of block being exited can be found by examining the Kind. A representing the specific kind of ExitStatementSyntax. One of ExitDoStatement, ExitForStatement, ExitSubStatement, ExitFunctionStatement, ExitOperatorStatement, ExitPropertyStatement, ExitTryStatement, ExitSelectStatement, ExitWhileStatement. The keyword describing the block to exit. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. A representing the specific kind of ContinueStatementSyntax. One of ContinueWhileStatement, ContinueDoStatement, ContinueForStatement. The "Continue" keyword. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. A representing the specific kind of ContinueStatementSyntax. One of ContinueWhileStatement, ContinueDoStatement, ContinueForStatement. The "Do", "For" or "While" keyword that identifies the kind of loop being continued. Represents a "Return" statement. The "Return" keyword. The expression being returned, if present. Represents a "Return" statement. The expression being returned, if present. Represents a "Return" statement. Represents a single-line "If ... Then ... Else ..." statement. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. A list of statements to be executed if the condition expression evaluates as true. Multiple statements must be separated by colons. An "Else" clause to be executed if the condition expression evaluates as false. Represents a single-line "If ... Then ... Else ..." statement. The condition expression to be evaluated. A list of statements to be executed if the condition expression evaluates as true. Multiple statements must be separated by colons. An "Else" clause to be executed if the condition expression evaluates as false. Represents a single-line "If ... Then ... Else ..." statement. The condition expression to be evaluated. Represents the "Else ..." clause of a single-line "If" statement. The "Else" keyword. A list of statements to be executed. Multiple statements must be separated by colons. Represents the "Else ..." clause of a single-line "If" statement. A list of statements to be executed. Multiple statements must be separated by colons. Represents the "Else ..." clause of a single-line "If" statement. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. The "If" statement that begins the "If" block. A list of statements to be executed if the condition expression evaluates as true. A list of "ElseIf" blocks to be evaluated, in order, if the condition expression of the "If" statement evaluates as false. An "Else" block to be executed if the condition expression of the "If" statement and all "ElseIf" blocks evaluate as false. Then "End If" statement. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. The "If" statement that begins the "If" block. A list of statements to be executed if the condition expression evaluates as true. A list of "ElseIf" blocks to be evaluated, in order, if the condition expression of the "If" statement evaluates as false. An "Else" block to be executed if the condition expression of the "If" statement and all "ElseIf" blocks evaluate as false. Represents a multi-line "If ... Then ... ElseIf ... Then ... Else ... End If" block. The "If" statement that begins the "If" block. Represents the "If ... Then" statement that begins a multi-line "If" block. The "If" keyword. The condition expression to be evaluated. The "Then" keyword. Represents the "If ... Then" statement that begins a multi-line "If" block. The condition expression to be evaluated. Represents an "ElseIf ... Then ..." block. The "ElseIf ... Then" statement the begins the "ElseIf" block. A list of statements to be executed if the condition expression of the "ElseIf" statement evaluates as true. Represents an "ElseIf ... Then ..." block. The "ElseIf ... Then" statement the begins the "ElseIf" block. Represents the "ElseIf ... Then" statement that begins an "ElseIf" block. The "ElseIf" keyword. The condition expression to be evaluated. The "Then" keyword. Represents the "ElseIf ... Then" statement that begins an "ElseIf" block. The condition expression to be evaluated. Represents an "Else ..." block. The "Else" statement that begins the "Else" block. A list of statements to be executed. Represents an "Else ..." block. A list of statements to be executed. Represents an "Else ..." block. Represents the "Else" statement that begins an "Else" block. The "Else" keyword. Represents the "Else" statement that begins an "Else" block. Represents a "Try ... Catch ... Finally ... End Try" block. The "Try" statement that begins the "Try" block. A list of statements to be executed. A list of "Catch" blocks which may be executed if an exception is thrown while executing the statements in the "Try" block. A "Finally" block to be executed before execution leaves the "Try" block. The "End Try" statement. Represents a "Try ... Catch ... Finally ... End Try" block. A list of statements to be executed. A list of "Catch" blocks which may be executed if an exception is thrown while executing the statements in the "Try" block. A "Finally" block to be executed before execution leaves the "Try" block. Represents a "Try ... Catch ... Finally ... End Try" block. Represents the "Try" statement that begins a "Try" block. The "Try" keyword. Represents the "Try" statement that begins a "Try" block. Represents a "Catch ..." block. The "Catch" statement that begins the "Catch" block. A list of statements to be executed if an exception is caught by the "Catch" block. Represents a "Catch ..." block. The "Catch" statement that begins the "Catch" block. Represents the "Catch ... When ..." statement that begins a "Catch" block. The "Catch" keyword. An identifier declaring a new variable or naming an existing variable to store the exception caught by the "Catch" statement. A simple "As" clause specifying the type of exception to catch. A "When" clause to filter exceptions before catching. Represents the "Catch ... When ..." statement that begins a "Catch" block. An identifier declaring a new variable or naming an existing variable to store the exception caught by the "Catch" statement. A simple "As" clause specifying the type of exception to catch. A "When" clause to filter exceptions before catching. Represents the "Catch ... When ..." statement that begins a "Catch" block. Represents the "When ..." clause of a "Catch" statement. The "When" keyword. The filter expression to be evaluated. Represents the "When ..." clause of a "Catch" statement. The filter expression to be evaluated. Represents a "Finally ..." block of a "Try" block. The "Finally" statement that begins the "Finally" block. A list of statements to be executed. Represents a "Finally ..." block of a "Try" block. A list of statements to be executed. Represents a "Finally ..." block of a "Try" block. Represents the "Finally" statement that begins a "Finally" block. The "Finally" keyword. Represents the "Finally" statement that begins a "Finally" block. Represents the "Error" statement. The "Error" keyword. The expression that represents the error number. Represents the "Error" statement. The expression that represents the error number. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. A representing the specific kind of OnErrorGoToStatementSyntax. One of OnErrorGoToZeroStatement, OnErrorGoToMinusOneStatement, OnErrorGoToLabelStatement. The "On" keyword The "Error" keyword. The "GoTo" keyword An optional minus for On Error Goto -1 The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Goto statement. A representing the specific kind of OnErrorGoToStatementSyntax. One of OnErrorGoToZeroStatement, OnErrorGoToMinusOneStatement, OnErrorGoToLabelStatement. The name of the label. If the label is a line number, 0 or -1, wraps an IntegerLiteralToken that is the line number, otherwise, wraps an Identifier. Represents an OnError Resume Next statement. The "On" keyword The "Error" keyword. The "Resume" keyword. The "Next" Represents an OnError Resume Next statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. A representing the specific kind of ResumeStatementSyntax. One of ResumeStatement, ResumeLabelStatement, ResumeNextStatement. The "Resume" keyword. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. A representing the specific kind of ResumeStatementSyntax. One of ResumeStatement, ResumeLabelStatement, ResumeNextStatement. The label. The value of this depends on the Kind. If Kind=Resume, returns Nothing. If Kind=ResumeNext, wraps the keyword "Next", If Kind=ResumeLabel, wraps an Identifier or IntegerLiteralToken with the label or line number. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. A representing the specific kind of ResumeStatementSyntax. One of ResumeStatement, ResumeLabelStatement, ResumeNextStatement. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. The Select Case statement that begins the block. A list of the contained Case blocks. The End Select statement that ends the block. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. The Select Case statement that begins the block. A list of the contained Case blocks. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. The Select Case statement that begins the block. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. The "Select" keyword. The "Case" keyword, if present. The value that branching is based on. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. The value that branching is based on. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a case statement and its subsequent block. The statement that begins the case block. Represents a case statement and its subsequent block. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a case statement and its subsequent block. The statement that begins the case block. Represents a case statement and its subsequent block. A representing the specific kind of CaseBlockSyntax. One of CaseBlock, CaseElseBlock. The statement that begins the case block. The statements contained in the case block. This might be an empty list. Represents a case statement and its subsequent block. A representing the specific kind of CaseBlockSyntax. One of CaseBlock, CaseElseBlock. The statement that begins the case block. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A representing the specific kind of CaseStatementSyntax. One of CaseStatement, CaseElseStatement. The "Case" keyword A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A representing the specific kind of CaseStatementSyntax. One of CaseStatement, CaseElseStatement. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. A representing the specific kind of CaseStatementSyntax. One of CaseStatement, CaseElseStatement. A list of clauses associated with this Case. If Kind=CaseElse, then this list has exactly one child, which is a ElseCaseClause. The "Else" part in a Case Else statement. The "Else" keyword. The "Else" part in a Case Else statement. Represents a single value in a Case. The expression that denotes the value being tested against. Represents a range "expression To expression" in a Case. The lower bound of the range. The "To" keyword The upper bound of the range. Represents a range "expression To expression" in a Case. The lower bound of the range. The upper bound of the range. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". A representing the specific kind of RelationalCaseClauseSyntax. One of CaseEqualsClause, CaseNotEqualsClause, CaseLessThanClause, CaseLessThanOrEqualClause, CaseGreaterThanOrEqualClause, CaseGreaterThanClause. The "Is" keyword, if present. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents a relation clause in a Case statement, such as "Is > expression". A representing the specific kind of RelationalCaseClauseSyntax. One of CaseEqualsClause, CaseNotEqualsClause, CaseLessThanClause, CaseLessThanOrEqualClause, CaseGreaterThanOrEqualClause, CaseGreaterThanClause. The operator in the relational clause. One of "=", "<", ">", "<=" or ">=". The expression that denotes the value being tested against. Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. The "SyncLock" keyword. The expression being synchronized on. Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. The expression being synchronized on. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. The Do statement that begins the block. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. A representing the specific kind of DoLoopBlockSyntax. One of SimpleDoLoopBlock, DoWhileLoopBlock, DoUntilLoopBlock, DoLoopWhileBlock, DoLoopUntilBlock. The Do statement that begins the block. The statements contained in the block statement. This might be an empty list. The Loop statement that ends the block. Represents a Do-Loop block. The Kind property can be used to determine if this is a Do While, Do Until, Do Loop While, Do Loop Until, or infinite Do Loop. A representing the specific kind of DoLoopBlockSyntax. One of SimpleDoLoopBlock, DoWhileLoopBlock, DoUntilLoopBlock, DoLoopWhileBlock, DoLoopUntilBlock. The Do statement that begins the block. The Loop statement that ends the block. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The Do statement that begins a Do-Loop block. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. The Do statement that begins a Do-Loop block. A representing the specific kind of DoStatementSyntax. One of SimpleDoStatement, DoWhileStatement, DoUntilStatement. The "Do" keyword. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. A representing the specific kind of DoStatementSyntax. One of SimpleDoStatement, DoWhileStatement, DoUntilStatement. The "While expression" or "Until expression" clause of the Do statement, if present. The Do statement that begins a Do-Loop block. A representing the specific kind of DoStatementSyntax. One of SimpleDoStatement, DoWhileStatement, DoUntilStatement. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The Loop statement that begins a Do-Loop block. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. The Loop statement that begins a Do-Loop block. A representing the specific kind of LoopStatementSyntax. One of SimpleLoopStatement, LoopWhileStatement, LoopUntilStatement. The "Loop" keyword. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. A representing the specific kind of LoopStatementSyntax. One of SimpleLoopStatement, LoopWhileStatement, LoopUntilStatement. The "While expression" or "Until expression" clause of the Loop statement, if present. The Loop statement that begins a Do-Loop block. A representing the specific kind of LoopStatementSyntax. One of SimpleLoopStatement, LoopWhileStatement, LoopUntilStatement. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The "While" or "Until" keyword. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. The boolean expression after the While or Until. Represents a "While expression" or "Until expression" in a Do or Loop statement. The Kind of the clause can be "WhileClause" or "UntilClause" to indicate which kind of clause. A representing the specific kind of WhileOrUntilClauseSyntax. One of WhileClause, UntilClause. The "While" or "Until" keyword. The boolean expression after the While or Until. The While statement that begins a While...End While block. This statement always occurs as the Begin of a WhileBlock. The "While" keyword. The boolean expression that controls the While loop. The While statement that begins a While...End While block. This statement always occurs as the Begin of a WhileBlock. The boolean expression that controls the While loop. Represents a For block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For statement that begins the block. The statements contained in the For or For Each loop. This might be an empty list. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. Represents a For block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For statement that begins the block. Represents a For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For Each statement that begins the block. The statements contained in the For or For Each loop. This might be an empty list. The Next statement that ends the block. If two For or For Each statements are ended by a single Next statement, the inner For will not have a Next statement. Represents a For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For Each statement that begins the block. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "For" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The "=" token. The expression denoting the initial value of the iteration. The "To" keyword. The expression denoting the final value of the iteration. The optional Step clause. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The expression denoting the initial value of the iteration. The expression denoting the final value of the iteration. The optional Step clause. The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The expression denoting the initial value of the iteration. The expression denoting the final value of the iteration. The Step clause in a For Statement. The "Step" keyword. The expression denoting the step increment. The Step clause in a For Statement. The expression denoting the step increment. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The "For" keyword. The "Each" keyword. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The "In" keyword. The expression denoting the collection to iterate over. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. If the For or For Each statement is of a form that does not declare a new loop control variable, this is the expression that denotes the loop control variable. If this loop is of a form that does declare a new control variable, this is a VariableDeclarator that has the variable being declared. The expression denoting the collection to iterate over. The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The "Next" keyword. The variables in the Next statement, if present The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The variables in the Next statement, if present The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. The "Using" keyword. If the Using statement is of a form that does not declare a new variable, this is the expression used in the using. Otherwise, Nothing is returned. If the Using statement is of a form that declares one or more new variables, this is the list of variable declarations. Otherwise, Nothing is returned. The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. If the Using statement is of a form that does not declare a new variable, this is the expression used in the using. Otherwise, Nothing is returned. If the Using statement is of a form that declares one or more new variables, this is the list of variable declarations. Otherwise, Nothing is returned. The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. Represents a Throw statement. The "Throw" keyword The expression denoting the value being thrown. Represents a Throw statement. The expression denoting the value being thrown. Represents a Throw statement. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. The target (left hand side) of the assignment. The source (right hand side) of the assignment. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. A representing the specific kind of AssignmentStatementSyntax. One of SimpleAssignmentStatement, MidAssignmentStatement, AddAssignmentStatement, SubtractAssignmentStatement, MultiplyAssignmentStatement, DivideAssignmentStatement, IntegerDivideAssignmentStatement, ExponentiateAssignmentStatement, LeftShiftAssignmentStatement, RightShiftAssignmentStatement, ConcatenateAssignmentStatement. The target (left hand side) of the assignment. The operator used in the assignment statement. One of "=", "+=", "-=", "*=", "/=", "\=", "^=", "&=", "<<=" or ">>=". The source (right hand side) of the assignment. Represents a left-hand side of a MidAssignment statement. The "Mid" possibly followed by a type character. The argument list. Represents a left-hand side of a MidAssignment statement. The "Mid" possibly followed by a type character. The argument list. Represent a call statement (also known as a invocation statement). The "Call" keyword. The expression denoting the call. This could be an Invocation or a MemberAccess (in the case where no parentheses were supplied.) Represent a call statement (also known as a invocation statement). The expression denoting the call. This could be an Invocation or a MemberAccess (in the case where no parentheses were supplied.) Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The event being accessed. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. The event being accessed. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. A representing the specific kind of AddRemoveHandlerStatementSyntax. One of AddHandlerStatement, RemoveHandlerStatement. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The "," token. The delegate being added or removed. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. A representing the specific kind of AddRemoveHandlerStatementSyntax. One of AddHandlerStatement, RemoveHandlerStatement. The "AddHandler" or "RemoveHandler" keyword. The event being accessed. The delegate being added or removed. Represent a RaiseEvent statement. The "RaiseEvent" keyword The name of the event being raised. The argument list, if present. Represent a RaiseEvent statement. The name of the event being raised. The argument list, if present. Represent a RaiseEvent statement. The name of the event being raised. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. The "With" keyword. The expression that is the operand of the With statement. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. The expression that is the operand of the With statement. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement. The list of ReDim clauses. Represents a ReDim statement. The list of ReDim clauses. Represents a ReDim statement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement. The list of ReDim clauses. Represents a ReDim statement. The list of ReDim clauses. Represents a ReDim statement. A representing the specific kind of ReDimStatementSyntax. One of ReDimStatement, ReDimPreserveStatement. The "ReDim" keyword. Returns Nothing if Kind=ReDim, returns the "Preserve" keyword if Kind=RedimPreserve. The list of ReDim clauses. Represents a ReDim statement. A representing the specific kind of ReDimStatementSyntax. One of ReDimStatement, ReDimPreserveStatement. The list of ReDim clauses. Represents a ReDim statement. A representing the specific kind of ReDimStatementSyntax. One of ReDimStatement, ReDimPreserveStatement. The list of ReDim clauses. Represents a ReDim statement clause. The target of the ReDim statement. The ArraySizeInitializationModifier. Represents an "Erase" statement. The "Erase" keyword. A list of expressions denoting the arrays to erase. Represents an "Erase" statement. A list of expressions denoting the arrays to erase. Represents an "Erase" statement. A list of expressions denoting the arrays to erase. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. A representing the specific kind of LiteralExpressionSyntax. One of CharacterLiteralExpression, TrueLiteralExpression, FalseLiteralExpression, NumericLiteralExpression, DateLiteralExpression, StringLiteralExpression, NothingLiteralExpression. The token that represents the literal. The Kind property determines what type this property returns: Kind=IntegerLiteral ==> Returns IntegerLiteralToken. Kind=CharacterLiteral ==> Returns CharacterLiteralToken. Kind=DecimalLiteral ==> Returns DecimalLiteralToken Kind=FloatingLiteral ==> Returns FloatingLiteralToken Kind=DateLiteral ==> Returns DateLiteralToken Kind=StringLiteral ==> Returns StringLiteralToken Kind=BooleanLiteral ==> Returns Keyword (with it's kind being TrueKeyword or FalseKeyword) Kind=NothingLiteral ==> Returns Keyword (with it's kind being NothingKeyword) Represents a parenthesized expression. The "(" token The expression inside the parentheses. The ")" token Represents a parenthesized expression. The expression inside the parentheses. Represents a tuple literal expression. The "(" token The list of tuple arguments. The ")" token Represents a tuple literal expression. The list of tuple arguments. Represents a tuple literal expression. The list of tuple arguments. Represents a tuple type expression. The "(" token The list of tuple elements. The ")" token Represents a tuple type expression. The list of tuple elements. Represents a tuple type expression. The list of tuple elements. Represents a single declaration of a tuple element supplying only the type. The type-name part of the tuple element syntax. Represents a single declaration of a tuple element supplying element name and optionally a type. The name of the element. A simple "As" clause specifying the type of the tuple element. Represents a single declaration of a tuple element supplying element name and optionally a type. The name of the element. Represents a single declaration of a tuple element supplying element name and optionally a type. The name of the element. Identifies the special instance "Me" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "Me" Identifies the special instance "MyBase" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "MyBase" Identifies the special instance "MyClass" The "Me", "MyClass" or "MyBase" keyword. Identifies the special instance "MyClass" Represents a GetType expression. The "GetType" keyword. The "(" token. The type to get the Type object for. This can be an open generic type. The ")" token. Represents a GetType expression. The type to get the Type object for. This can be an open generic type. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. The expression being tested. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. The expression being tested. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. A representing the specific kind of TypeOfExpressionSyntax. One of TypeOfIsExpression, TypeOfIsNotExpression. The "TypeOf" keyword. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a TypeOf...Is or IsNot expression. A representing the specific kind of TypeOfExpressionSyntax. One of TypeOfIsExpression, TypeOfIsNotExpression. The expression being tested. The "Is" or "IsNot" keyword. The name of the type being tested against. Represents a GetXmlNamespace expression. The "GetXmlNamespace" keyword. The "(" token. The Xml namespace name being referenced. The ")" token. Represents a GetXmlNamespace expression. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The expression on the left-hand-side of the "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. A representing the specific kind of MemberAccessExpressionSyntax. One of SimpleMemberAccessExpression, DictionaryAccessExpression. The expression on the left-hand-side of the "." or "!" token. The "." or "!" token. The identifier after the "." or "!" token. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. A representing the specific kind of MemberAccessExpressionSyntax. One of SimpleMemberAccessExpression, DictionaryAccessExpression. The "." or "!" token. The identifier after the "." or "!" token. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The "@" part of .@ or the second "." of "...". The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The "@" part of .@ or the second "." of "...". The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The expression on the left-hand-side of the ".", ".@" or "..." . The "@" part of .@ or the second "." of "...". The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. A representing the specific kind of XmlMemberAccessExpressionSyntax. One of XmlElementAccessExpression, XmlDescendantAccessExpression, XmlAttributeAccessExpression. The expression on the left-hand-side of the ".", ".@" or "..." . The initial dot "." part of the separator. The "@" part of .@ or the second "." of "...". The third "." in a "..." separator. The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. A representing the specific kind of XmlMemberAccessExpressionSyntax. One of XmlElementAccessExpression, XmlDescendantAccessExpression, XmlAttributeAccessExpression. The expression on the left-hand-side of the ".", ".@" or "..." . The "@" part of .@ or the second "." of "...". The identifier after the ".", ".@" or "..." Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. A representing the specific kind of XmlMemberAccessExpressionSyntax. One of XmlElementAccessExpression, XmlDescendantAccessExpression, XmlAttributeAccessExpression. The identifier after the ".", ".@" or "..." Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. The target of the call or index expression. The argument list. Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type of the object being initialized. The argument list, if present. If no argument list was supplied, Nothing is returned. An optional From or With clause to initialize the new object. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The type of the object being initialized. The argument list, if present. If no argument list was supplied, Nothing is returned. An optional From or With clause to initialize the new object. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. The type of the object being initialized. Represents a New expression that create an object of anonymous type. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The With clause to initialize the new object. Represents a New expression that create an object of anonymous type. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The With clause to initialize the new object. Represents a New expression that create an object of anonymous type. The With clause to initialize the new object. Represents an expression that creates a new array. The "New" keyword. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The element type of the array being created. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". A list of array modifiers such as "()" or "(,)". If no array modifiers were present, an empty list is returned. The initializer including the braces. Represents an expression that creates a new array. A list of all attribute lists on the type. If no attributes were specified, an empty list is returned. The element type of the array being created. The optional array bounds, such as "(4)" or "(0 to 5, 0 To 6)". The initializer including the braces. Represents an expression that creates a new array. The element type of the array being created. The initializer including the braces. Represents an expression that creates a new array without naming the element type. The "{" token. The list of initializers between the braces. The "}" token. Represents an expression that creates a new array without naming the element type. The list of initializers between the braces. Represents an expression that creates a new array without naming the element type. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The expression being cast. The type the expression is being cast to. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The expression being cast. The type the expression is being cast to. The "CType", "DirectCast" or "TryCast" keyword. The "(" token. The expression being cast. The "," token. The type the expression is being cast to. The ")" token. The expression being cast. The type the expression is being cast to. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. The keyword that was used in the cast operation. The "(" token. The expression being cast. The ")" token. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. The keyword that was used in the cast operation. The expression being cast. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. The left operand. The right operand. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. A representing the specific kind of BinaryExpressionSyntax. One of AddExpression, SubtractExpression, MultiplyExpression, DivideExpression, IntegerDivideExpression, ExponentiateExpression, LeftShiftExpression, RightShiftExpression, ConcatenateExpression, ModuloExpression, EqualsExpression, NotEqualsExpression, LessThanExpression, LessThanOrEqualExpression, GreaterThanOrEqualExpression, GreaterThanExpression, IsExpression, IsNotExpression, LikeExpression, OrExpression, ExclusiveOrExpression, AndExpression, OrElseExpression, AndAlsoExpression. The left operand. The right operand. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The token that is the operator. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. The expression being operated on. Describes a unary operator: Plus, Negate, Not or AddressOf. A representing the specific kind of UnaryExpressionSyntax. One of UnaryPlusExpression, UnaryMinusExpression, NotExpression, AddressOfExpression. The token that is the operator. The expression being operated on. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The first expression inside the parentheses. The second expression inside the parentheses. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The "If" keyword The "(" token The first expression inside the parentheses. The "," token. The second expression inside the parentheses. The "," token. The second expression inside the parentheses. The ")" token Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). The first expression inside the parentheses. The second expression inside the parentheses. The second expression inside the parentheses. Represents a single line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a single line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a single line lambda expression. A representing the specific kind of SingleLineLambdaExpressionSyntax. One of SingleLineFunctionLambdaExpression, SingleLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a Statement (single-line Sub lambda) or Expression (single-line Function). Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. A representing the specific kind of MultiLineLambdaExpressionSyntax. One of MultiLineFunctionLambdaExpression, MultiLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. The body of the lambda. Depending on the kind of lambda, this is either a StatementBody (multi-line lambda), Statement (single-line Sub lambda) or Expression (single-line Function). This might be an empty list. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents a multi-line lambda expression. A representing the specific kind of MultiLineLambdaExpressionSyntax. One of MultiLineFunctionLambdaExpression, MultiLineSubLambdaExpression. The header part of the lambda that includes the "Sub" or "Function" keyword, the argument list and return type. Returns the "End Sub" or "End Function" statement if this is a multi-line lambda. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression Represents the header part of a lambda expression A representing the specific kind of LambdaHeaderSyntax. One of SubLambdaHeader, FunctionLambdaHeader. A list of all attribute lists on this declaration. If no attributes were specified, Nothing is returned. A list of all the modifier tokens that were present on this declaration. If no modifiers were specified, an empty list is returned. A bitfield version of all the modifiers ORed together, which is in many cases easier to use, can be obtained with the Modifiers property. The "Sub" or "Function" keyword that introduces this lambda expression. The method's parameter list including the parentheses. If no parameter list was present, Nothing is returned. The "As" clause that describes the return type. If no As clause was present, Nothing is returned. Represents the header part of a lambda expression A representing the specific kind of LambdaHeaderSyntax. One of SubLambdaHeader, FunctionLambdaHeader. The "Sub" or "Function" keyword that introduces this lambda expression. Represents a parenthesized argument list. The "(" token. The list of arguments. This may be empty. Omitted argument are represented by an OmittedArgumentSyntax node. The ")" token. Represents a parenthesized argument list. The list of arguments. This may be empty. Omitted argument are represented by an OmittedArgumentSyntax node. Represents a parenthesized argument list. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. An empty token because all non terminals must have a token. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. Represents an argument that is just an optional argument name and an expression. The optional name and ":=" prefix of a named argument. The expression that is the argument. Represents an argument that is just an optional argument name and an expression. The expression that is the argument. Represents an identifier name followed by a ":=" token in a named argument. The name used to identify the named argument. The ":=" token. Represents an identifier name followed by a ":=" token in a named argument. The name used to identify the named argument. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. The lower bound of the range. This is typically the integer constant zero. The "To" keyword. The upper bound of the range. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. The lower bound of the range. This is typically the integer constant zero. The upper bound of the range. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. A list of all the query operators in this query expression. This list always contains at least one operator. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. A list of all the query operators in this query expression. This list always contains at least one operator. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. The name of the range variable being defined. Describes the type of the variable being defined. The "In" keyword. The expression that serves as the source of items for the range variable. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. The name of the range variable being defined. Describes the type of the variable being defined. The expression that serves as the source of items for the range variable. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. The name of the range variable being defined. The expression that serves as the source of items for the range variable. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the expression. The expression used to initialize the expression variable. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. The expression used to initialize the expression variable. Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. The optional name and type of the expression range variable. If omitted, the name of the expression range variable is inferred from the aggregation expression. The name of the aggregation function. The "Group" aggregation function is represented by the identifier "Group". Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. The name of the aggregation function. The "Group" aggregation function is represented by the identifier "Group". Represents the name and optional type of an expression range variable. The name of the variable being defined. Describes the type of the variable being defined. The "=" token. Represents the name and optional type of an expression range variable. The name of the variable being defined. Describes the type of the variable being defined. Represents the name and optional type of an expression range variable. The name of the variable being defined. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. The "(" token if present. The argument to the aggregation function. The ")" token, if present. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. The argument to the aggregation function. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. The name of the aggregation function. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. The "Group" keyword. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. The "From" keyword. The list of collection variables declared by this From operator. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. The list of collection variables declared by this From operator. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. The list of collection variables declared by this From operator. Represents a "Let" query operator. The "Let" keyword. The list of expression range variable being defined by the Let operator. Represents a "Let" query operator. The list of expression range variable being defined by the Let operator. Represents a "Let" query operator. The list of expression range variable being defined by the Let operator. Represents an Aggregate query operator. The "Aggregate" keyword. The list of collection range variables declared by this Aggregate operator. A list of additional query operators. It may be empty. The "Into" keyword. The list of new variables being defined by the aggregation. Represents an Aggregate query operator. The list of collection range variables declared by this Aggregate operator. A list of additional query operators. It may be empty. The list of new variables being defined by the aggregation. Represents an Aggregate query operator. The list of collection range variables declared by this Aggregate operator. The list of new variables being defined by the aggregation. Represents the "Distinct" query operator. The "Distinct" keyword. Represents the "Distinct" query operator. Represents a "Where" query operator. The "Where" keyword. The boolean expression used for filtering. Represents a "Where" query operator. The boolean expression used for filtering. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. A representing the specific kind of PartitionWhileClauseSyntax. One of SkipWhileClause, TakeWhileClause. The "Skip" or "Take" keyword. The "While" keyword. The boolean expression used for partitioning. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. A representing the specific kind of PartitionWhileClauseSyntax. One of SkipWhileClause, TakeWhileClause. The "Skip" or "Take" keyword. The boolean expression used for partitioning. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. Represents the expression with the number of items to take or skip. Represents a "Skip" or "Take" query operator. The Kind property tells which. A representing the specific kind of PartitionClauseSyntax. One of SkipClause, TakeClause. The "Skip" or "Take" keyword. Represents the expression with the number of items to take or skip. Represents the "Group By" query operator. The "Group" keyword. The optional list of variables being grouped; the contents of the Group clause. If none were specified, an empty list is returned. The "By" keyword. The key values being used for grouping. The list of new variables that calculate aggregations. Represents the "Group By" query operator. The optional list of variables being grouped; the contents of the Group clause. If none were specified, an empty list is returned. The key values being used for grouping. The list of new variables that calculate aggregations. Represents the "Group By" query operator. The key values being used for grouping. The list of new variables that calculate aggregations. Represents the "expression Equals expression" condition in a Join. The left expression in the Join condition. The "Equals" keyword. The right expression in the Join condition. Represents the "expression Equals expression" condition in a Join. The left expression in the Join condition. The right expression in the Join condition. Represents a Join query operator. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Represents a Join query operator. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Represents a Join query operator. Defines the collection range variables being joined to. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. Represents the "Group Join" query operator. The "Group" keyword. The "Join" keyword. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The "On" keyword. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. The "Into" keyword. The list of new variables that calculate aggregations. Represents the "Group Join" query operator. Defines the collection range variables being joined to. An additional Join or Group Join query operator. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. The list of new variables that calculate aggregations. Represents the "Group Join" query operator. Defines the collection range variables being joined to. The conditions indicating what expressions to compare during the join. Each condition is a JoinCondition, and the separators are "And" keywords. The list of new variables that calculate aggregations. Represents the "Order By" query operator. The "Order" keyword The "By" keyword. The list of OrderExpression's to sort by. Represents the "Order By" query operator. The list of OrderExpression's to sort by. Represents the "Order By" query operator. The list of OrderExpression's to sort by. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. The expression to sort by. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. A representing the specific kind of OrderingSyntax. One of AscendingOrdering, DescendingOrdering. The expression to sort by. The "Ascending" or "Descending" keyword, if present. To determine whether to sort in ascending or descending order, checking the Kind property is easier. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. A representing the specific kind of OrderingSyntax. One of AscendingOrdering, DescendingOrdering. The expression to sort by. Represents the "Select" query operator. The "Select" keyword. The list of expression range variables being defined by the Select query operator. Represents the "Select" query operator. The list of expression range variables being defined by the Select query operator. Represents the "Select" query operator. The list of expression range variables being defined by the Select query operator. Represents an XML Document literal expression. Represents an XML Document literal expression. Represents the XML declaration prologue in an XML literal expression. Represents the XML declaration prologue in an XML literal expression. Represents the XML declaration prologue in an XML literal expression. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. Represents an XML element with content in an XML literal expression. Represents an XML element with content in an XML literal expression. Represents Xml text. A list of all the text tokens in the Xml text. This list always contains at least one token. Represents Xml text. Represents the start tag of an XML element of the form <element>. Represents the start tag of an XML element of the form <element>. Represents the start tag of an XML element of the form <element>. Represents the end tag of an XML element of the form </element>. Represents the end tag of an XML element of the form </element>. Represents the end tag of an XML element of the form </element>. Represents an empty XML element of the form <element /> Represents an empty XML element of the form <element /> Represents an empty XML element of the form <element /> Represents an XML attribute in an XML literal expression. Represents an XML attribute in an XML literal expression. Represents a string of XML characters embedded as the content of an XML element. Represents a string of XML characters embedded as the content of an XML element. Represents an XML name of the form 'name' appearing in GetXmlNamespace(). Represents an XML name of the form 'name' appearing in GetXmlNamespace(). Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. Represents an XML CDATA section in an XML literal expression. Represents an XML CDATA section in an XML literal expression. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. The type of the elements of the array. Represents the list of "()" or "(,,)" modifiers on the array type. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. The type of the elements of the array. A type name that represents a nullable type, such as "Integer?". The kind of type that is this type is a nullable of. Cannot be an array type or a nullable type. The "?" token. A type name that represents a nullable type, such as "Integer?". The kind of type that is this type is a nullable of. Cannot be an array type or a nullable type. Represents an occurrence of a Visual Basic built-in type such as Integer or String in source code. The keyword that was used to describe the built-in type. Represents a type name consisting of a single identifier (which might include brackets or a type character). The identifier in the name. Represents a type name consisting of a single identifier (which might include brackets or a type character). The identifier in the name. Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). The identifier in the name. The generic argument list. Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). The identifier in the name. The generic argument list. Represents a qualified type name, for example X.Y or X(Of Z).Y. The part of the name that appears to the left of the dot. This can itself be any name. The "." token that separates the names. The part of the name that appears to the right of the dot. This must be a simple identifier. Represents a qualified type name, for example X.Y or X(Of Z).Y. The part of the name that appears to the left of the dot. This can itself be any name. The part of the name that appears to the right of the dot. This must be a simple identifier. Represents a name in the global namespace. The "Global" keyword. Represents a name in the global namespace. Represents a parenthesized list of generic type arguments. The "(" token. The "Of" keyword. A list of all the type arguments. The ")" token. Represents a parenthesized list of generic type arguments. A list of all the type arguments. Represents a parenthesized list of generic type arguments. A list of all the type arguments. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. Represent a Yield statement. The "Yield" keyword. The expression whose value is being yielded. Represent a Yield statement. The expression whose value is being yielded. Represents an Await expression. The "Await" keyword. The expression being awaited. Represents an Await expression. The expression being awaited. Represents an Xml NCName per Namespaces in XML 1.0 The actual text of this token. Represents an Xml NCName per Namespaces in XML 1.0 The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. A representing the specific kind of XmlTextTokenSyntax. One of XmlTextLiteralToken, XmlEntityLiteralToken, DocumentationCommentLineBreakToken. The actual text of this token. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. A representing the specific kind of XmlTextTokenSyntax. One of XmlTextLiteralToken, XmlEntityLiteralToken, DocumentationCommentLineBreakToken. The actual text of this token. Represents literal character data in interpolated string expression. The actual text of this token. Represents literal character data in interpolated string expression. The actual text of this token. Represents a Decimal literal token. The actual text of this token. Represents a Decimal literal token. The actual text of this token. Represents a Date literal token. The actual text of this token. Represents a Date literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents a string literal token. The actual text of this token. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. The list of tokens that were skipped by the parser. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. Represents a documentation comment e.g. ''' <Summary> appearing in source. Represents a documentation comment e.g. ''' <Summary> appearing in source. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. ExpressionSyntax node representing the object conditionally accessed. The expression on the left-hand-side of the "?". "?" token. ExpressionSyntax node representing the access expression to be executed when the object is not null." ExpressionSyntax node representing the object conditionally accessed. The expression on the left-hand-side of the "?". ExpressionSyntax node representing the access expression to be executed when the object is not null." ExpressionSyntax node representing the object conditionally accessed. ExpressionSyntax node representing the access expression to be executed when the object is not null." Represents a NameOf expression. The "NameOf" keyword. The "(" token. The argument. The ")" token. Represents a NameOf expression. The argument. Represents an interpolated string expression. The opening '$"', '$“', or '$”' token. The contents of the interpolated string. The closing '"', '”', or '“' token. Represents an interpolated string expression. The contents of the interpolated string. Represents an interpolated string expression. The contents of the interpolated string. Represents literal text content in an interpolated string. The text token. Represents literal text content in an interpolated string. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. The opening curly brace '{' token. The expression whose formatted value should be embedded in the resultant string. Optional. The alignment clause ',alignment' of the embedded expression. Optional. The format string clause ':formatString' of the embedded expression. The closing curly brace '}' token of the embedded expression. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. The expression whose formatted value should be embedded in the resultant string. Optional. The alignment clause ',alignment' of the embedded expression. Represents an interpolation of an expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. The expression whose formatted value should be embedded in the resultant string. Represents an alignment clause ',alignment' of an interpolated string embedded expression. The comma ',' token. An expression representing the alignment of the interpolated expression. Represents an alignment clause ',alignment' of an interpolated string embedded expression. An expression representing the alignment of the interpolated expression. Represents a format string clause ':formatString' of an interpolated string embedded expression. The ':' token. The format string. Represents a format string clause ':formatString' of an interpolated string embedded expression. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. The actual text of this token. Trivia nodes represents parts of the program text that are not parts of the syntactic grammar, such as spaces, newlines, comments, preprocessors directives, and disabled code. A representing the specific kind of SyntaxTrivia. One of WhitespaceTrivia, EndOfLineTrivia, ColonTrivia, CommentTrivia, ConflictMarkerTrivia, LineContinuationTrivia, DocumentationCommentExteriorTrivia, DisabledTextTrivia. The actual text of this token. Represents a #Const pre-processing constant declaration appearing in source. The "#" token in a preprocessor directive. The "Const" keyword. The name of the pre-processing constant being defined. The "=" token. An expression representing the value of the pre-processing constant being defined. Represents a #Const pre-processing constant declaration appearing in source. The name of the pre-processing constant being defined. An expression representing the value of the pre-processing constant being defined. Represents a #Const pre-processing constant declaration appearing in source. The name of the pre-processing constant being defined. An expression representing the value of the pre-processing constant being defined. Represents the beginning of an #If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of an #If pre-processing directive appearing in source. Represents the beginning of an #If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of an #If pre-processing directive appearing in source. Represents the beginning of an #If pre-processing directive appearing in source. A representing the specific kind of IfDirectiveTriviaSyntax. One of IfDirectiveTrivia, ElseIfDirectiveTrivia. The "#" token in a preprocessor directive. Represents the beginning of an #If pre-processing directive appearing in source. A representing the specific kind of IfDirectiveTriviaSyntax. One of IfDirectiveTrivia, ElseIfDirectiveTrivia. Represents an #Else pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #Else pre-processing directive appearing in source. Represents an #End If pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #End If pre-processing directive appearing in source. Represents the beginning of a #Region directive appearing in source. The "#" token in a preprocessor directive. The "Region" keyword. The label of the code region being defined. Represents the beginning of a #Region directive appearing in source. Represents an #End Region directive appearing in source. The "#" token in a preprocessor directive. The "End" keyword. The "Region" keyword. Represents an #End Region directive appearing in source. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. Represents an #End ExternalSource pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #End ExternalSource pre-processing directive appearing in source. Represents an #ExternalChecksum pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents an #ExternalChecksum pre-processing directive appearing in source. Represents #Enable Warning pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents #Enable Warning pre-processing directive appearing in source. Represents #Enable Warning pre-processing directive appearing in source. Represents #Disable Warning pre-processing directive appearing in source. The "#" token in a preprocessor directive. Represents #Disable Warning pre-processing directive appearing in source. Represents #Disable Warning pre-processing directive appearing in source. Represents an #r directive appearing in scripts. The "#" token in a preprocessor directive. Represents an #r directive appearing in scripts. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. The "#" token in a preprocessor directive. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. A trivia with kind EndOfLineTrivia containing both the carriage return And line feed characters. A trivia with kind EndOfLineTrivia containing a single line feed character. A trivia with kind EndOfLineTrivia containing a single carriage return character. A trivia with kind WhitespaceTrivia containing a single space character. A trivia with kind WhitespaceTrivia containing a single tab character. An elastic trivia with kind EndOfLineTrivia containing both the carriage return And line feed characters. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. An elastic trivia with kind EndOfLineTrivia containing a single line feed character. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. An elastic trivia with kind EndOfLineTrivia containing a single carriage return character. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. An elastic trivia with kind WhitespaceTrivia containing a single space character. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. An elastic trivia with kind WhitespaceTrivia containing a single tab character. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. An elastic trivia with kind WhitespaceTrivia containing no characters. Elastic marker trivia are included automatically by factory methods when trivia Is Not specified. Syntax formatting will replace elastic markers with appropriate trivia. Creates a trivia with kind EndOfLineTrivia containing the specified text. The text of the end of line. Any text can be specified here, however only carriage return And line feed characters are recognized by the parser as end of line. Creates a trivia with kind EndOfLineTrivia containing the specified text. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. The text of the end of line. Any text can be specified here, however only carriage return And line feed characters are recognized by the parser as end of line. Creates a trivia with kind WhitespaceTrivia containing the specified text. The text of the whitespace. Any text can be specified here, however only specific whitespace characters are recognized by the parser. Creates a trivia with kind WhitespaceTrivia containing the specified text. Elastic trivia are used to denote trivia that was Not produced by parsing source text, And are usually Not preserved during formatting. The text of the whitespace. Any text can be specified here, however only specific whitespace characters are recognized by the parser. Names on the right of qualified names and member access expressions are not stand-alone expressions. This method returns the appropriate parent of name syntax nodes that are on right of these constructs. Creates a token with kind IntegerLiteralToken from a 4-byte signed integer value. The 4-byte signed integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 4-byte signed integer value. The raw text of the literal. The 4-byte signed integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 4-byte signed integer value. A list of trivia immediately preceding the token. The raw text of the literal. The 4-byte signed integer value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind IntegerLiteralToken from a 4-byte unsigned integer value. The 4-byte unsigned integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 4-byte unsigned integer value. The raw text of the literal. The 4-byte unsigned integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 4-byte unsigned integer value. A list of trivia immediately preceding the token. The raw text of the literal. The 4-byte unsigned integer value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind IntegerLiteralToken from an 8-byte signed integer value. The 8-byte signed integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 8-byte signed integer value. The raw text of the literal. The 8-byte signed integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 8-byte signed integer value. A list of trivia immediately preceding the token. The raw text of the literal. The 8-byte signed integer value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind IntegerLiteralToken from an 8-byte unsigned integer value. The 8-byte unsigned integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 8-byte unsigned integer value. The raw text of the literal. The 8-byte unsigned integer value to be represented by the returned token. Creates a token with kind IntegerLiteralToken from the text and corresponding 8-byte unsigned integer value. A list of trivia immediately preceding the token. The raw text of the literal. The 8-byte unsigned integer value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind FloatingLiteralToken from a 4-byte floating point value. The 4-byte floating point value to be represented by the returned token. Creates a token with kind FloatingLiteralToken from the text and corresponding 4-byte floating point value. The raw text of the literal. The 4-byte floating point value to be represented by the returned token. Creates a token with kind FloatingLiteralToken from the text and corresponding 4-byte floating point value. A list of trivia immediately preceding the token. The raw text of the literal. The 4-byte floating point value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind FloatingLiteralToken from an 8-byte floating point value. The 8-byte floating point value to be represented by the returned token. Creates a token with kind FloatingLiteralToken from the text and corresponding 8-byte floating point value. The raw text of the literal. The 8-byte floating point value to be represented by the returned token. Creates a token with kind FloatingLiteralToken from the text and corresponding 8-byte floating point value. A list of trivia immediately preceding the token. The raw text of the literal. The 8-byte floating point value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind DecimalLiteralToken from a decimal value. The decimal value to be represented by the returned token. Creates a token with kind DecimalLiteralToken from the text and corresponding decimal value. The raw text of the literal. The decimal value to be represented by the returned token. Creates a token with kind DecimalLiteralToken from the text and corresponding decimal value. A list of trivia immediately preceding the token. The raw text of the literal. The decimal value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind StringLiteralToken from a string value. The string value to be represented by the returned token. Creates a token with kind StringLiteralToken from the text and corresponding string value. The raw text of the literal, including quotes and escape sequences. The string value to be represented by the returned token. Creates a token with kind StringLiteralToken from the text and corresponding string value. A list of trivia immediately preceding the token. The raw text of the literal, including quotes and escape sequences. The string value to be represented by the returned token. A list of trivia immediately following the token. Creates a token with kind CharacterLiteralToken from a character value. The character value to be represented by the returned token. Creates a token with kind CharacterLiteralToken from the text and corresponding character value. The raw text of the literal, including quotes and escape sequences. The character value to be represented by the returned token. Creates a token with kind CharacterLiteralToken from the text and corresponding character value. A list of trivia immediately preceding the token. The raw text of the literal, including quotes and escape sequences. The character value to be represented by the returned token. A list of trivia immediately following the token. Creates an xml documentation comment that abstracts xml syntax creation. A list of xml node syntax that will be the content within the xml documentation comment (e.g. a summary element, a returns element, exception element and so on). Creates a summary element within an xml documentation comment. A list of xml node syntax that will be the content within the summary element. Creates a summary element within an xml documentation comment. A list of xml node syntax that will be the content within the summary element. Creates a see element within an xml documentation comment. A cref syntax node that points to the referenced item (e.g. a class, struct). Creates a seealso element within an xml documentation comment. A cref syntax node that points to the referenced item (e.g. a class, struct). Creates a seealso element within an xml documentation comment. The uri of the referenced item. A list of xml node syntax that will be used as the link text for the referenced item. Creates a threadsafety element within an xml documentation comment. Creates a threadsafety element within an xml documentation comment. Indicates whether static member of this type are safe for multi-threaded operations. Indicates whether instance members of this type are safe for multi-threaded operations. Creates a syntax node for a name attribute in a xml element within a xml documentation comment. The value of the name attribute. Creates a syntax node for a preliminary element within a xml documentation comment. Creates a syntax node for a cref attribute within a xml documentation comment. The used for the xml cref attribute syntax. Creates a syntax node for a cref attribute within a xml documentation comment. The used for the xml cref attribute syntax. The kind of the quote for the referenced item in the cref attribute. Creates a remarks element within an xml documentation comment. A list of xml node syntax that will be the content within the remarks element. Creates a remarks element within an xml documentation comment. A list of xml node syntax that will be the content within the remarks element. Creates a returns element within an xml documentation comment. A list of xml node syntax that will be the content within the returns element. Creates a returns element within an xml documentation comment. A list of xml node syntax that will be the content within the returns element. Creates the syntax representation of an xml value element (e.g. for xml documentation comments). A list of xml syntax nodes that represents the content of the value element. Creates the syntax representation of an xml value element (e.g. for xml documentation comments). A list of xml syntax nodes that represents the content of the value element. Creates the syntax representation of an exception element within xml documentation comments. Syntax representation of the reference to the exception type. A list of syntax nodes that represents the content of the exception element. Creates the syntax representation of an exception element within xml documentation comments. Syntax representation of the reference to the exception type. A list of syntax nodes that represents the content of the exception element. Creates the syntax representation of a permission element within xml documentation comments. Syntax representation of the reference to the permission type. A list of syntax nodes that represents the content of the permission element. Creates the syntax representation of a permission element within xml documentation comments. Syntax representation of the reference to the permission type. A list of syntax nodes that represents the content of the permission element. Creates the syntax representation of an example element within xml documentation comments. A list of syntax nodes that represents the content of the example element. Creates the syntax representation of an example element within xml documentation comments. A list of syntax nodes that represents the content of the example element. Creates the syntax representation of a para element within xml documentation comments. A list of syntax nodes that represents the content of the para element. Creates the syntax representation of a para element within xml documentation comments. A list of syntax nodes that represents the content of the para element. Creates the syntax representation of a param element within xml documentation comments (e.g. for documentation of method parameters). The name of the parameter. A list of syntax nodes that represents the content of the param element (e.g. the description and meaning of the parameter). Creates the syntax representation of a param element within xml documentation comments (e.g. for documentation of method parameters). The name of the parameter. A list of syntax nodes that represents the content of the param element (e.g. the description and meaning of the parameter). Creates the syntax representation of a paramref element within xml documentation comments (e.g. for referencing particular parameters of a method). The name of the referenced parameter. Creates the syntax representation of a see element within xml documentation comments, that points to the 'null' language keyword. Creates the syntax representation of a see element within xml documentation comments, that points to a language keyword. The language keyword to which the see element points to. Creates the syntax representation of a placeholder element within xml documentation comments. A list of syntax nodes that represents the content of the placeholder element. Creates the syntax representation of a placeholder element within xml documentation comments. A list of syntax nodes that represents the content of the placeholder element. Creates the syntax representation of a named empty xml element within xml documentation comments. The name of the empty xml element. Creates the syntax representation of a named xml element within xml documentation comments. The name of the empty xml element. A list of syntax nodes that represents the content of the xml element. Creates the syntax representation of a named xml element within xml documentation comments. The name of the empty xml element. A list of syntax nodes that represents the content of the xml element. Creates the syntax representation of an xml element that spans multiple text lines. The name of the xml element. A list of syntax nodes that represents the content of the xml multi line element. Creates the syntax representation of an xml element that spans multiple text lines. The name of the xml element. A list of syntax nodes that represents the content of the xml multi line element. Creates the syntax representation of an xml text that contains a newline token with a documentation comment exterior trivia at the end (continued documentation comment). The raw text within the new line. Creates the syntax representation of an xml newline token with a documentation comment exterior trivia at the end (continued documentation comment). The raw text within the new line. Creates a token with kind XmlTextLiteralNewLineToken. The raw text of the literal. The xml text new line value. A list of trivia immediately preceding the token. A list of trivia immediately following the token. Creates the syntax representation of an xml newline token for xml documentation comments. The raw text within the new line. If set to true, a documentation comment exterior token will be added to the trailing trivia of the new token. Generates the syntax representation of a xml text node (e.g. for xml documentation comments). The string literal used as the text of the xml text node. Generates the syntax representation of a xml text node (e.g. for xml documentation comments). A list of text tokens used as the text of the xml text node. Generates the syntax representation of an xml text literal. The text used within the xml text literal. Generates the syntax representation of an xml text literal. The raw text of the literal. The text used within the xml text literal. Helper method that replaces less-than and greater-than characters with brackets. The original token that is to be replaced. The new rewritten token. Returns the new rewritten token with replaced characters. Determines if two trees are the same, disregarding trivia differences. The original tree. The new tree. True to ignore any differences of nodes inside bodies of methods, operators, constructors and accessors, and field and auto-property initializers, otherwise all nodes and tokens must be equivalent. Determines if two syntax nodes are the same, disregarding trivia differences. The old node. The new node. True to ignore any differences of nodes inside bodies of methods, operators, constructors and accessors, and field and auto-property initializers, otherwise all nodes and tokens must be equivalent. Determines if two syntax nodes are the same, disregarding trivia differences. The old node. The new node. If specified called for every child syntax node (not token) that is visited during the comparison. It it returns true the child is recursively visited, otherwise the child and its subtree is disregarded. Determines if two syntax tokens are the same, disregarding trivia differences. The old token. The new token. Determines if two lists of tokens are the same, disregarding trivia differences. The old token list. The new token list. Determines if two lists of syntax nodes are the same, disregarding trivia differences. The old list. The new list. If specified called for every child syntax node (not token) that is visited during the comparison. It returns true the child is recursively visited, otherwise the child and its subtree is disregarded. Determines if two lists of syntax nodes are the same, disregarding trivia differences. The old list. The new list. If specified called for every child syntax node (not token) that is visited during the comparison. It returns true the child is recursively visited, otherwise the child and its subtree is disregarded. Determines if a submission contains a LINQ query not followed by an empty line. Examples: 1. Dim x = 1 returns false since the statement is not a LINQ query 2. Dim x = FROM {1, 2, 3} return false since the statement is followed by an empty new line. 3. Dim x = FROM {1, 2, 3} returns true since the LINQ statement is not followed by an empty new line. Last expected token of the last statement in a submission. Top level statement which token is part of. Token that marks the end of submission. Determines if a submission is complete. Returns false if the syntax is valid but incomplete. Returns true if the syntax is invalid or complete. Throws in case the tree is null. Throws in case the tree is not a submission. Syntax tree. Create a new syntax tree from a syntax node. Produces a syntax tree by parsing the source text. Produces a syntax tree by parsing the source text. Produces a syntax tree by parsing the source text. Produces a syntax tree by parsing the source text. Parse the input for leading trivia. The input string The starting offset in the string Parse the input for trailing trivia. The input string The starting offset in the string Parse one token. The input string The starting offset in the string Scan using rules for the start of a statement Parse tokens in the input. Since this API does not create a that owns all produced tokens, the API may yield surprising results for the produced tokens and its behavior is generally unspecified. The input string The starting offset in the string The position of the first token Parse a name. The input string The starting offset in the string Parse a type name. The input string The starting offset in the string Parse a type name. The input string The starting offset in the string Parse an expression. The input string The starting offset in the string Parse an executable statement. The input string The starting offset in the string Parse a compilation unit (a single source file). The input string The starting offset in the string Parse a parameter list. The input string The starting offset in the string Parse an argument list. The input string The starting offset in the string Helper method for wrapping a string and offset in a SourceText. Try parse the attribute represented as a stand-alone string like [cref="A.B"] and recognize 'cref' and 'name' attributes like in documentation-comment mode. This method should only be used internally from code handling documentation comment includes. Create a bracketed identifier. Create a bracketed identifier. Create a missing identifier. Create a missing contextual keyword. Create a missing keyword. Create a missing punctuation mark. Create a missing string literal. Create a missing character literal. Create a missing integer literal. Creates a copy of a token. The new token Creates an empty list of syntax nodes. The specific type of the element nodes. Creates a singleton list of syntax nodes. The specific type of the element nodes. The single element node. Creates a list of syntax nodes. The specific type of the element nodes. A sequence of element nodes. Creates an empty list of tokens. Creates a singleton list of tokens. The single token. Creates a list of tokens. An array of tokens. Creates a list of tokens. Creates an empty list of trivia. Creates a singleton list of trivia. A single trivia. Creates a list of trivia. An array of trivia. Creates a list of trivia. A sequence of trivia. Creates an empty separated list. The specific type of the element nodes. Creates a singleton separated list. The specific type of the element nodes. A single node. Creates a separated list of nodes from a sequence of nodes, synthesizing comma separators in between. The specific type of the element nodes. A sequence of syntax nodes. Creates a separated list of nodes from a sequence of nodes and a sequence of separator tokens. The specific type of the element nodes. A sequence of syntax nodes. A sequence of token to be interleaved between the nodes. The number of tokens must be one less than the number of nodes. Creates a separated list from a sequence of nodes or tokens. The sequence must start with a node and alternate between nodes and separator tokens. The specific type of the element nodes. A alternating sequence of nodes and tokens. Creates a separated list from a . The must start with a node and alternate between nodes and separator tokens. The specific type of the element nodes. An alternating list of nodes and tokens. Creates an empty . Creates a from a sequence of nodes and tokens. A sequence of nodes and tokens. Creates a from one or more nodes and tokens. An array of nodes and tokens. Provides members for determining Syntax facts about characters and Unicode conversions. Return keyword or punctuation text based on SyntaxKind Determines if Unicode character represents a whitespace. The Unicode character. A boolean value set to True if character represents whitespace. Determines if Unicode character represents a XML whitespace. The unicode character A boolean value set to True if character represents XML whitespace. Determines if the Unicode character is a newline character. The Unicode character. A boolean value set to True if character is a newline character. Determines if the unicode character is a colon character. The unicode character. A boolean value set to True if character is a colon character. Determines if the unicode character is a underscore character. The unicode character. A boolean value set to True if character is an underscore character. Determines if the unicode character is a hash character. The unicode character. A boolean value set to True if character is a hash character. Determines if the Unicode character can be the starting character of a Visual Basic identifier. The Unicode character. A boolean value set to True if character can be part of a valid start character in an identifier. Determines if the Unicode character can be a part of a Visual Basic identifier. The Unicode character. A boolean value set to True if character can be part of a valid identifier. Determines if the name is a valid identifier. The identifier name. A boolean value set to True if name is valid identifier. Creates a half width form Unicode character string. The text representing the original identifier. This can be in full width or half width Unicode form. A string representing the text in a half width Unicode form. matches one char or another. Typical usage is for matching lowercase and uppercase. matches one char or another. it will try normal width and then fullwidth variations. Typical usage is for matching lowercase and uppercase. Determine if the token instance represents a syntax trivia such as comment, whitespace, etc... Get all reserved and contextual keywords Helper to check whether the token is a predefined type True if it is a predefined type Helper to check whether the token is a predefined type OR Variant keyword True if it is a predefined type OR Variant keyword Returns true if the node is the object of an invocation expression Returns true if the node is the operand of an AddressOf expression Returns true if the node is the operand of an AddressOf expression, or the object of an invocation. This is used for special binding rules around the return value variable inside Functions and Property Get accessors. Determines if position is before or within the span of a node, or in the trailing trivia of a node up to, but not including, a newline or colon trivia (which mark the end of a statement.) Determines if position is within the span of a node, or in the trailing trivia of a node up to, but not including, a newline or colon trivia (which mark the end of a statement.) Determines if possibleLambda is a lambda expression and position is in the interior. If "node" is a block statement return the Begin statement of "node", otherwise return "node". Checks if the SyntaxNode is an attribute name. To be an attribute name, the syntax must be parented by an Attribute and the node itself must be equal to the Attribute.Name property. Is the node the name of a named argument of an invocation or object creation expression, but not an attribute. Return keyword or punctuation text based on SyntaxKind Indicates whether a newline may validly follow the specified SyntaxToken without requiring an explicit line continuation sequence ' _' or terminating the containing statement. The token to test. This token must be parented by a SyntaxNode. True if implicit line continuation is allowed after token. Refer to "Statements in Visual Basic", 2010 version, http://msdn.microsoft.com/en-us/library/865x40k4(v=vs.100).aspx for examples. Implicit line continuation may be used in Visual Basic: After a comma (,). After a less-than sign (<) or before a greater-than sign (>) when you specify an attribute. After an open parenthesis (() or before a closing parenthesis ()). After an open curly brace ({) or before a closing curly brace (}). After an open embedded expression (<%=) or before the close of an embedded expression (%>) within an XML literal. Before and after query operators (Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, and Descending). You cannot break a line between the keywords of query operators that are made up of multiple keywords (Order By, Group Join, Take While, and Skip While). After the concatenation operator (&). After assignment operators (=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=). After binary operators (+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor) within an expression. After the Is and IsNot operators. After a less-than sign (<) or before a greater-than sign (>) when you specify an attribute. Also after a greater-than sign (>) when you specify an attribute. However, you must include a line-continuation character (_) when you specify assembly-level or module-level attributes. After a member qualifier character (.) and before the member name. However, you must include a line-continuation character (_) following a member qualifier character when you are using the With statement or supplying values in the initialization list for a type. After an XML axis property qualifier (. or ...). However, you must include a line-continuation character (_) when you specify a member qualifier when you are using the With keyword. After the From keyword in a collection initializer. After the With keyword in a member initializer. After the In keyword in a For Each statement. Indicates whether a newline may validly precede the specified SyntaxToken without requiring an explicit line continuation sequence ' _' or terminating the containing statement. The token to test. This token must be parented by a SyntaxNode. True if implicit line continuation is allowed after token. Refer to "Statements in Visual Basic", 2010 version, http://msdn.microsoft.com/en-us/library/865x40k4(v=vs.100).aspx for examples. Implicit line continuation may be used in Visual Basic: After a comma (,). After a less-than sign (<) or before a greater-than sign (>) when you specify an attribute. After an open parenthesis (() or before a closing parenthesis ()). After an open curly brace ({) or before a closing curly brace (}). After an open embedded expression (<%=) or before the close of an embedded expression (%>) within an XML literal. Before and after query operators (Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, and Descending). You cannot break a line between the keywords of query operators that are made up of multiple keywords (Order By, Group Join, Take While, and Skip While). After the concatenation operator (&). After assignment operators (=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=). After binary operators (+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor) within an expression. After the Is and IsNot operators. After a less-than sign (<) or before a greater-than sign (>) when you specify an attribute. Also after a greater-than sign (>) when you specify an attribute. However, you must include a line-continuation character (_) when you specify assembly-level or module-level attributes. After a member qualifier character (.) and before the member name. However, you must include a line-continuation character (_) following a member qualifier character when you are using the With statement or supplying values in the initialization list for a type. After an XML axis property qualifier (. or ...). However, you must include a line-continuation character (_) when you specify a member qualifier when you are using the With keyword. After the From keyword in a collection initializer. After the With keyword in a member initializer. After the In keyword in a For Each statement. Checks whether the element name is reserved. For example: "Item3" is reserved. "Rest", "ToString" and other members of System.ValueTuple are reserved. Names that are not reserved return False. A custom equality comparer for PERF: The framework specializes EqualityComparer for enums, but only if the underlying type is System.Int32 Since SyntaxKind's underlying type is System.UInt16, ObjectEqualityComparer will be chosen instead. Determine if the kind represents a reserved keyword Determine if the kind represents a contextual keyword Determine if the token instance represents 'Me', 'MyBase' or 'MyClass' keywords Return correspondent expression syntax for 'Me', 'MyBase' and 'MyClass' keywords or SyntaxKind.None for other syntax kinds Determine if the token instance represents a preprocessor keyword Get all reserved keywords Get contextual keywords Get punctuations Get preprocessor keywords Return keyword or punctuation text based on SyntaxKind Represents a Visual Basic global imports. The import clause (a namespace name, an alias, or an XML namespace alias). The import name. Parses a specified string to create a GlobalImport instance. The string containing the text to be parsed. A GlobalImport instance. Parses a specified string to create a GlobalImport instance with diagnostics info. The string containing the text to be parsed. An ImmutableArray of diagnostics created during parse. A GlobalImport instance. Parses a collection of strings representing imports to create collection of GlobalImports. The collection of strings to be parsed. A collection of GlobalImports Parses a parameter array of string arrays representing imports to create a collection of GlobalImports. The string arrays to be parsed. A collection of GlobalImports. Parses a collection of strings representing imports to create a collection of GlobalImport instance and diagnostics A collection of strings to be parsed. A ImmutableArray of diagnostics. A collection of GlobalImports. Determines if the current object is equal to another object. An object to compare with this object A boolean value. True if the current object is equal to the other parameter; otherwise, False. Determines whether the current object is equal to another object of the same type. A GlobalImport object to compare with this object A boolean value. True if the current object is equal to the other parameter; otherwise, False. Creates a hashcode for this instance. A hashcode representing this instance. Operator for Equality with GlobalImport Objects. True if the two items are Equal. Overloaded Operator for Inequality ith GlobalImport Objects. Returns True if the two items are not Equal. Supported Visual Basic language versions. Map a language version (such as Default, Latest, Or VisualBasicN) to a specific version (VisualBasicN). Displays the version number in the format understood on the command-line (/langver flag). For instance, "9", "15", "latest". Parse a LanguageVersion from a string input, as the command-line compiler does. Inference of tuple element names was added in VB 15.3 A program location in source code. A program location in MyTemplate code. Represents a VB location in source code or metadata. Spill a list of expressions (e.g. the arguments of a method call). The expressions are processed right-to-left. Once an expression has been found that contains an await expression, all subsequent expressions are spilled. Example: (1 + 2, await t1, Goo(), await t2, 3 + 4) becomes: Spill( spill1 = 1 + 2, spill2 = await t1, spill3 = Goo(), (spill1, spill2, spill3, await t2, 3 + 4)) NOTE: Consider nested array initializers: new int[] { { 1, await t1 }, { 3, await t2 } } If the arguments of the top-level initializer had already been spilled, we would end up trying to spill something like this: new int[] { Spill( spill1 = 1, { spill1, await t1 }), Spill( spill2 = 3, { spill2, await t2 }) } The normal rewriting would produce: Spill( spill1 = 1, spill3 = { spill1, await t1 }, spill2 = 3, int[] a = new int[] { spill3, { spill2, await t2 })) Which is invalid, because spill3 does not have a type. To solve this problem the expression list spilled descends into nested array initializers. The method being rewritten. The field of the generated async class used to store the async method builder: an instance of AsyncVoidMethodBuilder, AsyncTaskMethodBuilder, or AsyncTaskMethodBuilder(Of T) depending on the return type of the async method. The exprReturnLabel is used to label the return handling code at the end of the async state-machine method. Return expressions are rewritten as unconditional branches to exprReturnLabel. The exitLabel is used to label the final method body return at the end of the async state-machine method. Is used in rewriting of return statements from Await expressions and a couple of other places where the return is not accompanied by return of the value. The field of the generated async class used in generic task returning async methods to store the value of rewritten return expressions. The return-handling code then uses SetResult on the async method builder to make the result available to the caller. Generate the body for MoveNext() Materialize the capture, e.g. return an expression to be used instead of captured symbol Add proxy field(s) if any to the array builder provided Note: is used for binding BoundStateMachineScope with correspondent local/field references Create assignment expressions initializing for this capture, is only supposed to be used for proper handling of reference assignments Spill field allocator controls allocation and reuse of the set of fields used to spilling expressions; current implementation allows reuse of fields of the same type on high-level statement level Rewrite an async method into a state machine class. Returns true if any members that we need are missing or have use-site errors. Specifies a kind of an Async method None is returned for non-Async methods or methods with wrong return type Returns method's async kind The closure doesn't declare any variables. Display class Is a singleton And may be shared with other top-level methods. The closure only contains a reference to the containing class instance ("Me"). We don't emit a display class, lambdas are emitted directly to the containing class as its instance methods. General closure. Display class may only contain lambdas defined in the same top-level method. Rewrite lambda that are being converted to LINQ expression trees (Expression(Of T)) A lot of code is #If False disabled until it can be tested. Rewrite a bound lambda into a bound node that will create the corresponding expression tree at run time. Create an Expression Tree Node with the given name and arguments Create an Expression node with the given name, type arguments, and arguments. The shift count for a left-shift or right-shift operator needs to be masked according to the type of the left hand side, unless the shift count is an in-range constant. This is similar to what is done in code gen. Given user defined conversion node replace the operand with the coalesce lambda parameter. The input bound conversion node must have the following form: --> BoundConversion [UserDefined] --> [optional] BoundConversion (OutConversion) --> BoundCall [shared method, no receiver, one argument] The OUTPUT bound conversion node will have the following form: --> BoundConversion *updated* --> [optional] BoundConversion *updated* --> BoundCall [shared method, no receiver, * updated argument *] --> [optional] BoundConversion (parameter from nullable to value) --> *parameter* Rewrites a built-in conversion. Doesn't handle user-defined conversions or Nothing literals. Get the conversion helper for converting between special types in an expression tree. These are often different than the ones used in regular code. Get the name of the expression tree function for a particular unary operator This type provides means for instrumenting compiled methods for dynamic analysis. It can be combined with other s. Utility class, provides a convenient way of combining various s in a chain, allowing each of them to apply specific instrumentations in particular order. Default implementation of all APIs delegates to the "previous" passed as a parameter to the constructor of this class. Usually, derived types are going to let the base (this class) to do its work first and then operate on the result they get back. This type is responsible for adding debugging sequence points for the executable code. It can be combined with other s. Usually, this class should be the root of the chain in order to ensure sound debugging experience for the instrumented code. In other words, sequence points are typically applied after all other changes. A singleton object that performs only one type of instrumentation - addition of debugging sequence points. A base class for components that instrument various portions of executable code. It provides a set of APIs that are called by to instrument specific portions of the code. These APIs often have two parameters: - original bound node produced by the for the relevant portion of the code; - rewritten bound node created by the for the original node. The APIs are expected to return new state of the rewritten node, after they apply appropriate modifications, if any. The base class provides default implementation for all APIs, which simply returns the rewritten node. The singleton NoOp instrumenter, can be used to terminate the chain of s. Return a node that is associated with an entry of the block. OK to return Nothing. Ok to return Nothing when is Nothing. Return a prologue. Ok to return Nothing. Return an epilogue. Ok to return Nothing. Return an epilogue. Ok to return Nothing. Ok to return Nothing when is Nothing. Ok to return Nothing when is Nothing. Ok to return Nothing when is Nothing. Ok to return Nothing when is Nothing. Return a node that is associated with an entry of the Else block. Ok to return Nothing. Return a node that is associated with an entry of the block. Ok to return Nothing. Note, this method is only called for a catch block without Filter. If there is a filter, is called instead. Return a node that is associated with an entry of the Finally block. Ok to return Nothing. Return a node that is associated with an entry of the Try block. Ok to return Nothing. Ok to return Nothing. Ok to return Nothing when is Nothing. If is not Nothing, add to the end, not to the front. Ok to return Nothing when is Nothing. If is not Nothing, add to the end, not to the front. Ok to return Nothing. Ok to return Nothing. Ok to return Nothing. Ok to return Nothing. The field of the generated iterator class that underlies the Current property. Rewrite an iterator method into a state machine class. Returns true if any members that we need are missing or have use-site errors. A field of a frame class that represents a variable that has been captured in a lambda. A class that represents the set of variables in a scope that have been captured by lambdas within that scope. Copy constructor has one parameter of the same type as the enclosing type. The purpose is to copy all the lifted values from previous version of the frame if there was any into the new one. The rewriter for removing lambda expressions from method bodies and introducing closure classes as containers for captured variables along the lines of the example in section 6.5.3 of the C# language specification. The entry point is the public method Rewrite. It operates as follows: First, an analysis of the whole method body is performed that determines which variables are captured, what their scopes are, and what the nesting relationship is between scopes that have captured variables. The result of this analysis is left in LambdaRewriter.analysis. Then we make frame, or compiler-generated class, represented by an instance of LambdaRewriter.Frame for each scope with captured variables. The generated frames are kept in LambdaRewriter.frames. Each frame is given a single field for each captured variable in the corresponding scope. These are maintained in LambdaRewriter.proxies. Finally, we walk and rewrite the input bound tree, keeping track of the following: (1) The current set of active frame pointers, in LambdaRewriter.framePointers (2) The current method being processed (this changes within a lambda's body), in LambdaRewriter.currentMethod (3) The "this" symbol for the current method in LambdaRewriter.currentFrameThis, and (4) The symbol that is used to access the innermost frame pointer (it could be a local variable or "this" parameter) There are a few key transformations done in the rewriting. (1) Lambda expressions are turned into delegate creation expressions, and the body of the lambda is moved into a new, compiler-generated method of a selected frame class. (2) On entry to a scope with captured variables, we create a frame object and store it in a local variable. (3) References to captured variables are transformed into references to fields of a frame class. In addition, the rewriting deposits into the field LambdaRewriter.generatedMethods a (MethodSymbol, BoundStatement) pair for each generated method. LambdaRewriter.Rewrite produces its output in two forms. First, it returns a new bound statement for the caller to use for the body of the original method. Second, it returns a collection of (MethodSymbol, BoundStatement) pairs for additional method that the lambda rewriter produced. These additional methods contain the bodies of the lambdas moved into ordinary methods of their respective frame classes, and the caller is responsible for processing them just as it does with the returned bound node. For example, the caller will typically perform iterator method and asynchronous method transformations, and emit IL instructions into an assembly. Perform a first analysis pass in preparation for removing all lambdas from a method body. The entry point is Analyze. The results of analysis are placed in the fields seenLambda, blockParent, variableBlock, captured, and captures. Set to true of any lambda expressions were seen in the analyzed method body. Set to true if method body contains any back branches (loops). For each statement with captured variables, identifies the nearest enclosing statement with captured variables. For each captured variable, identifies the statement in which it will be moved to a frame class. This is normally the block where the variable is introduced, but method parameters are moved to a frame class within the body of the method. For a given label, the nearest enclosing block that captures variables For a given goto, the nearest enclosing block that captures variables Blocks that contain (recursively) a lambda that is lifting. Such blocks are considered as potentially needing closure initialization when doing jump verification. Blocks that are positioned between a block declaring some lifted variables and a block that contains the lambda that lifts said variables. If such block itself requires a closure, then it must lift parent frame pointer into the closure in addition to whatever else needs to be lifted. NOTE: This information is computed in addition to the regular analysis of the tree and only needed for rewriting. If someone only needs diagnostics or information about captures, this information is not necessary. ComputeLambdaScopesAndFrameCaptures needs to be called to compute this. Optimized locations of lambdas. Lambda does not need to be placed in a frame that corresponds to its lexical scope if lambda does not reference any local state in that scope. It is advantageous to place lambdas higher in the scope tree, ideally in the innermost scope of all scopes that contain variables captured by a given lambda. Doing so reduces indirections needed when captured local are accessed. For example locals from the innermost scope can be accessed with no indirection at all. NOTE: This information is computed in addition to the regular analysis of the tree and only needed for rewriting. If someone only needs diagnostics or information about captures, this information is not necessary. ComputeLambdaScopesAndFrameCaptures needs to be called to compute this. The set of captured variables seen in the method body. For each lambda in the code, the set of variables that it captures. The set of variables that were declared anywhere inside an expression lambda. Set to true while we are analyzing the interior of an expression lambda. All symbols that should never be captured with a copy constructor of a closure. Analyzes method body that belongs to the given method symbol. Create the optimized plan for the location of lambda methods and whether scopes need access to parent scopes Compute the nesting depth of a given block. Topmost block (where method locals and parameters are defined) are at the depth 0. Once we see a lambda lifting something We mark all scopes from the current up to the one that declares lifted symbol as containing a lifting lambda. This is needed so that we could reject jumps that might jump over frame allocations. NOTE: because of optimizations lambda _might_ be placed in a frame higher than its lexical scope and thus make a jump technically legal. However, we explicitly do not consider frame optimizations in this analysis. This method is called on every variable reference. It checks for cases where variable is declared outside of the lambda in which it is being accessed If capture is detected, than it marks variable as capturED and all lambdas involved as capturING For performance reason we may not want to check if synthetic gotos are legal. Those are the majority, but should not be ever illegal (how user would fix them?). WARNING: used ONLY in DEBUG Rewrite the given node to eliminate lambda expressions. Also returned are the method symbols and their bound bodies for the extracted lambda bodies. These would typically be emitted by the caller such as MethodBodyCompiler. See this class' documentation for a more thorough explanation of the algorithm and its use by clients. The bound node to be rewritten The containing method of the node to be rewritten Index of the method symbol in its containing type member list. Information on lambdas defined in needed for debugging. EnC rude edit information on lambdas defined in . Information on closures defined in needed for debugging. The caller's buffer into which we produce additional methods to be emitted by the caller Set of symbols that should not be captured using a copy constructor The caller's buffer into which we place any diagnostics for problems encountered Create the frame types. Produces a bound expression representing a pointer to a frame of a particular frame type. The syntax to attach to the bound nodes produced The type of frame to be returned A bound node that computes the pointer to the required frame Produce a bound expression representing a pointer to a frame of a particular frame class. Note that for generic frames, the frameClass parameter is the generic definition, but the resulting expression will be constructed with the current type parameters. The syntax to attach to the bound nodes produced The class type of frame to be returned A bound node that computes the pointer to the required frame Constructs a concrete frame type if needed. Introduce a frame around the translation of the given node. The node whose translation should be translated to contain a frame The frame for the translated node A function that computes the translation of the node. It receives lists of added statements and added symbols The translated statement, as returned from F If parameter (or variable in the EE) is lifted, initialize its proxy. Rewrites lambda body into a body of a method. Method symbol for the rewritten lambda body. Original lambda node. Lambda body rewritten as a body of the given method symbol. It is illegal to jump into blocks that reference lifted variable as that could leave closure frames of the target block uninitialized. The fact that closure could be created as high as the declaration level of the variable and well above goto block (thus making the jump safe) is considered an optional optimization and ignored. For the purpose of this analysis just having lifting lambdas already means that block may require initialization and cannot be jumped into. Note that when you are jumping into a block you are essentially jumping into ALL blocks on the path from LowestCommonAncestor(goto, label) to the actual label block. Optimize the case where we create an instance of a delegate and invoke it right away. Skip the delegate creation and invoke the method directly. Specifically, we are targeting lambda relaxation scenario that requires a stub, which invokes original lambda by instantiating an Anonymous Delegate and calling its Invoke method. That is why this optimization should be done after lambdas are rewritten. CONSIDER: Should we expand this optimization to all delegate types and all explicitly written code? If we decide to do this, we should be careful with extension methods because they have special treatment of 'this' parameter. A method that results from the translation of a single lambda expression. Creates a symbol for a synthesized lambda method Type that contains lambda method - it is either Frame or enclosing class in a case if we do not lift anything. Method that contains lambda expression for which we do the rewrite. Lambda expression which is represented by this method. Returns substitution currently used by the rewriter for a placeholder node. Each occurrence of the placeholder node is replaced with the node returned. Throws if there is no substitution. Sets substitution used by the rewriter for a placeholder node. Each occurrence of the placeholder node is replaced with the node returned. Throws if there is already a substitution. Replaces substitution currently used by the rewriter for a placeholder node with a different substitution. Asserts if there isn't already a substitution. Removes substitution currently used by the rewriter for a placeholder node. Asserts if there isn't already a substitution. Adds a prologue before stepping on the statement NOTE: if the statement is a block the prologue will be outside of the scope Gets the special type. Special Type to get. Gets the special type member. Member of the special type. Checks for special member and reports diagnostics if the member is Nothing or has UseSiteError. Returns True in case diagnostics was actually reported Checks for special member and reports diagnostics if the member is Nothing or has UseSiteError. Returns True in case diagnostics was actually reported Checks for well known member and reports diagnostics if the member is Nothing or has UseSiteError. Returns True in case diagnostics was actually reported Checks for well known member and reports diagnostics if the member is Nothing or has UseSiteError. Returns True in case diagnostics was actually reported If value is const, returns the value unchanged. In a case if value is not a const, a proxy temp is created and added to "locals" In addition to that, code that evaluates and stores the value is added to "expressions" The access expression to the proxy temp is returned. Helper method to create a bound sequence to represent the idea: "compute this value, and then compute this side effects while discarding results" A Bound sequence is generated for the provided expr and side-effects, say {se1, se2, se3}, as follows: If expr is of void type: BoundSequence { side-effects: { expr, se1, se2, se3 }, valueOpt: Nothing } ElseIf expr is a constant: BoundSequence { side-effects: { se1, se2, se3 }, valueOpt: expr } Else BoundSequence { side-effects: { tmp = expr, se1, se2, se3 }, valueOpt: tmp } NOTE: Supporting cases where side-effects change the value (or to detect such cases) NOTE: could be complicated. We do not support this currently and instead require NOTE: value expr to be not LValue. Helper function that visits the given expression and returns a BoundExpression. Please use this instead of DirectCast(Visit(expression), BoundExpression) If we have a WinRT type event, we need to encapsulate the adder call (which returns an EventRegistrationToken) with a call to WindowsRuntimeMarshal.AddEventHandler or RemoveEventHandler, but these require us to create a new Func representing the adder and another Action representing the remover. The rewritten call looks something like: WindowsRuntimeMarshal.AddEventHandler(Of TEventHandler)( New Func(Of TEventHandler, EventRegistrationToken)([object].add_T), New Action(Of EventRegistrationToken)([object].remove_T), New TEventHandler(Me.OnSuspending)) where [object] is a compiler-generated local temp. For a remover, the call looks like: WindowsRuntimeMarshal.RemoveEventHandler(Of TEventHandler)( New Action(Of EventRegistrationToken)([object].remove_T), New TEventHandler(Me.OnSuspending)) Make sure GetObjectValue calls are injected. Apply GetObjectValue call if needed. Apply GetObjectValue call if needed. The goal of optimization is to eliminate the need to deal with instances of Nullable(Of Boolean) type as early as possible, and, as a result, simplify evaluation of built-in OrElse/AndAlso operators by eliminating the need to use three-valued Boolean logic. The optimization is possible because when an entire Boolean Expression is evaluated to Null, that has the same effect as if result of evaluation was False. However, we do want to preserve the original order of evaluation, according to language rules. This method returns an expression that still has Nullable(Of Boolean) type, but that expression is much simpler and can be further simplified by the consumer. Is this a floating-point operation that results in a whole number, rendering a following rounding operation redundant? Is this a floating-point truncation operation that would be redundant if followed by a truncation to an integral type? Converts access to a tuple instance into access into the underlying ValueTuple(s). For instance, tuple.Item8 produces fieldAccess(field=Item1, receiver=fieldAccess(field=Rest, receiver=ValueTuple for tuple)) Field initializers need to be rewritten multiple times in case of an AsNew declaration with multiple field names because the initializer may contain references to the current field like in the following example: Class C1 Public x, y As New RefType() With {.Field1 = .Field2} End Class in this example .Field2 references the temp that is created for x and y. We moved the final rewriting for field initializers to the local rewriters because here we already have the infrastructure to replace placeholders. Rewrites a for each statement. The node. Rewrites a for each over an one dimensional array or a string. As an optimization, if c is an array type of rank 1, the form becomes: Dim collectionCopy As C = c Dim collectionIndex As Integer = 0 Do While collectionIndex < len(collectionCopy) ' len(a) represents the LDLEN opcode dim controlVariable = DirectCast(collectionCopy(collectionIndex), typeOfControlVariable) <loop body> continue: collectionIndex += 1 postIncrement: Loop An iteration over a string becomes Dim collectionCopy As String = c Dim collectionIndex As Integer = 0 Dim limit as Integer = s.Length Do While collectionIndex < limit dim controlVariable = DirectCast(collectionCopy.Chars(collectionIndex), typeOfControlVariable) <loop body> continue: collectionIndex += 1 postIncrement: Loop The node. The statements. The locals. if set to true [is array]. Creates a local and assigns it the given bound expression. The syntax node. The initialization expression. The bound local. The locals. Creates the index increment statement. The syntax node. The bound index expression (bound local). Creates the while statement for the for each rewrite The limit to check the index against. The index. The assignment statement of the current value. The increment statement. The bound for each node. The lowered statement list for the while statement. Rewrite a for each that uses IEnumerable. It's basic form is: Dim e As E = c.GetEnumerator() Do While e.MoveNext() controlVariable = e.Current <loop body> Loop To support disposable enumerators, the compiler will generate code to dispose the enumerator after loop termination. Only when E implements IDisposable can this be done. The one exception to this rule is when E is specifically IEnumerator, in which case the compiler will generate code to dynamically query the enumerator to determine if it implements IDisposable. If E is IEnumerator the loop becomes: Dim e As IEnumerator = c.GetEnumerator() Try Do While e.MoveNext() dim controlVariable = e.Current <loop body> Loop Finally If TryCast(e, IDisposable) IsNot Nothing then CType(e, IDisposable).Dispose() End If End Try If E is known at compile time to implement IDisposable the loop becomes: Dim e As E = c.GetEnumerator() Try Do While e.MoveNext() dim controlVariable = e.Current <loop body> Loop Finally If Not e Is Nothing Then CType(e, IDisposable).Dispose() End If End Try The exception to these forms is the existence of On Error in which case the Try/Finally block will be eliminated (instead the body of the Finally will immediately follow the end of the loop). Depending on whether the bound local's type is, implements or inherits IDisposable for sure, or might implement it, this function returns the statements to call Dispose on the bound local. If it's known to implement IDisposable, the generated code looks like this for reference types: If e IsNot Nothing Then CType(e, IDisposable).Dispose() End If or e.Dispose() for value types (including type parameters with a value constraint). Otherwise it looks like the following If TryCast(e, IDisposable) IsNot Nothing then CType(e, IDisposable).Dispose() End If This method is used by the for each rewriter and the using rewriter. The latter should only call this method with both IsOrInheritsFromOrImplementsIDisposable and needToDispose set to true, as using is not pattern based and must implement IDisposable. The syntax node. The bound local. The condition used in the if statement around the dispose call A flag indicating whether the bound local's type is, inherits or implements IDisposable or not. Conversion from the local type to IDisposable Internal helper class to replace local symbols in bound locals of a given bound tree. Rewrites ForTo loop. Negates the value if step is negative Given the control variable, limit and step, produce the loop condition. The principle is simple - if step is negative (stepping "Up") then it is "control >= limit" otherwise it is "control <= limit" It gets more complicated when step is not a constant or not a numeric or involves overloaded comparison/IsTrue operators Attempt to retrieve the specified special member, reporting a use-site diagnostic if the member is not found. Replaces local declaration with its initializer Also marks resulting statement with seq point that matches original declaration. Splits nullable operand into a hasValueExpression and an expression that represents underlying value (returned). Underlying value can be called after calling hasValueExpr without duplicated side-effects. Note that hasValueExpr is guaranteed to have NO SIDE-EFFECTS, while result value is expected to be called exactly ONCE. That is the normal pattern in operator lifting. All necessary temps and side-effecting initializations are appended to temps and inits Returns a NOT-SIDE-EFFECTING expression that represents results of the operand If such transformation requires a temp, the temp and its initializing expression are returned in temp/init Returns expression that - a) evaluates the operand if needed b) produces it's ValueOrDefault. The helper is familiar with wrapping expressions and will go directly after the value skipping wrap/unwrap steps. Evaluates expr and calls HasValue on it. Checks that candidate Null expression is a simple expression that produces Null of the desired type (not a conversion or anything like that) and returns it. Otherwise creates "New T?()" expression. returns true when expression has NO SIDE-EFFECTS and is known to produce nullable NULL Returns true when expression is known to produce nullable NOT-NULL NOTE: unlike HasNoValue case, HasValue expressions may have side-effects. Helper to generate binary expressions. Performs some trivial constant folding. TODO: Perhaps belong to a different file Simpler helper for binary expressions. When operand are boolean, the result type is same as operand's and is never checked so do not need to pass that in. Takes two expressions and makes sequence. Takes two expressions and makes sequence. Takes two expressions and makes sequence. Returns an expression that can be used instead of the original one when we want to run the expression for side-effects only (i.e. we intend to ignore result). Rewrites a CollectionInitializerExpression to a list of Add calls and returns the temporary. E.g. the following code: Dim x As New CollectionType(param1) From {1, {2, 3}, {4, {5, 6, 7}}} gets rewritten to Dim temp as CollectionType temp = new CollectionType(param1) temp.Add(1) temp.Add(2, 3) temp.Add(4, {5, 6, 7}) x = temp where the last assignment is not part of this rewriting, because the BoundCollectionInitializerExpression only represents the object creation expression with the initialization. The BoundCollectionInitializerExpression that should be rewritten. A bound sequence for the object creation expression containing the invocation expressions. Rewrites a ObjectInitializerExpression to either a statement list (in case the there is no temporary used) or a bound sequence expression (in case there is a temporary used). The information whether to use a temporary or not is stored in the bound object member initializer node itself. E.g. the following code: Dim x = New RefTypeName(param1) With {.FieldName1 = 23, .FieldName2 = .FieldName3, .FieldName4 = x.FieldName1} gets rewritten to Dim temp as RefTypeName temp = new RefTypeName(param1) temp.FieldName1 = 23 temp.FieldName2 = temp.FieldName3 temp.FieldName4 = x.FieldName1 x = temp where the last assignment is not part of this rewriting, because the BoundObjectInitializerExpression only represents the object creation expression with the initialization. In a case where no temporary is used the following code: Dim x As New ValueTypeName(param1) With {.FieldName1 = 23, .FieldName2 = .FieldName3, .FieldName4 = x.FieldName1} gets rewritten to x = new ValueTypeName(param1) x.FieldName1 = 23 x.FieldName2 = x.FieldName3 x.FieldName4 = x.FieldName1 The BoundObjectInitializerExpression that should be rewritten. A bound sequence for the object creation expression containing the invocation expressions, or a bound statement list if no temporary should be used. Rewrites Return as a GoTo is needed (if not the last statement in a method) digs into known concat operators and unwraps their arguments otherwise returns the expression as-is Generally we only need to recognize same node patterns that we create as a result of concatenation rewrite. We could recognize some other nodes and unwrap to arguments folds two concat operands into one expression if possible otherwise returns null folds two concat constants into one if possible otherwise returns null. It is generally always possible to concat constants, unless resulting string would be too large. Strangely enough there is such a thing as unary concatenation and it must be rewritten. Is there any code to execute in the given statement that could have side-effects, such as throwing an exception? This implementation is conservative, in the sense that it may return true when the statement actually may have no side effects. Converts the expression for creating a tuple instance into an expression creating a ValueTuple (if short) or nested ValueTuples (if longer). For instance, for a long tuple we'll generate: creationExpression(ctor=largestCtor, args=firstArgs+(nested creationExpression for remainder, with smaller ctor and next few args)) A using statement of the form: using Expression list_of_statements end using will be rewritten into: temp = Expression Try list_of_statements Finally If Temp IsNot Nothing Then CType(temp, IDisposable).Dispose() End If End Try when the resource is a using locally declared variable no temporary is generated but the variable is read-only A using statement of the form: Using v As New MyDispose() list_of_statements End Using is rewritten to: Dim v As New MyDispose() Try list_of_statements Finally If v IsNot Nothing Then CType(v, IDisposable).Dispose() End If End Try A using with multiple variable resources are equivalent to a nested using statement. So a using statement of the form: Using v1 As New MyDispose(), v2 As myDispose = New MyDispose() list_of_statements end using is rewritten to: Dim v1 As New MyDispose Try Dim v2 As MyDispose = new MyDispose() Try list_of_statements Finally If v2 IsNot Nothing Then CType(v2, IDisposable).Dispose() End If End Try Finally If v1 IsNot Nothing Then CType(v1, IDisposable).Dispose() End If end try Creates a TryFinally Statement for the given resource. This method creates the following for the arguments: <localSymbol> = <initializationExpression> Try <currentBody> Finally If <disposeCondition> Then <disposeConversion>.Dispose() End If End Try Note: this is used for both kinds of using statements (resource locals and resource expressions). The new bound block containing the assignment of the initialization and the try/finally statement with the passed body. Cache of value types which were already calculated by LocalOrFieldNeedsToBeCleanedUp in this lowering, serves as an optimization Create a temp local of the given type and initial value. The resulting local is treated as an rvalue, and the initialization assignment is added to 'sideEffects'. Create a BoundExpression representing an array creation initialized with the given items. If there are zero items, the result is a BoundLiteral Nothing, otherwise, a BoundArrayCreation. A bound node rewriter that rewrites types properly (which in some cases the automatically-generated). This is used in the lambda rewriter, the iterator rewriter, and the async rewriter. A method that wraps the call to a method through MyBase/MyClass receiver. Class A Protected Overridable Sub F(a As Integer) End Sub End Class Class B Inherits A Public Sub M() Dim b As Integer = 1 Dim f As System.Action = Sub() MyBase.F(b) End Sub End Class Creates a symbol for a method that wraps the call to a method through MyBase/MyClass receiver. Type that contains wrapper method. Method to wrap Wrapper method name Syntax node. For each captured variable, the corresponding field of its frame A mapping from every local variable to its replacement local variable. Local variables are replaced when their types change due to being inside of a lambda within a generic method. A mapping from every parameter to its replacement parameter. Local variables are replaced when their types change due to being inside of a lambda. The mapping of type parameters for the current lambda body The method (e.g. lambda) which is currently being rewritten. If we are rewriting a lambda, currentMethod is the new generated method. A not-null collection of synthesized methods generated for the current source type. During rewriting, we ignore locals that have already been rewritten to a proxy (a field on a closure class). However, in the EE, we need to preserve the original slots for all locals (slots for any new locals must be appended after the originals). The field is intended to suppress any rewriter logic that would result in original locals being omitted. Rewrites method. Rewrites property. Rewrites field. Represents a synthesized state machine helper field. Type used by State Machine rewriter to represent symbol proxy. Lambda rewriter as well as iterator rewriter use simplified form of proxy as they only capture locals as r-values in fields, async rewriter uses a different structure as a proxy because it has to capture l-values on stack as well The "state" of the state machine that is the translation of the iterator method. Cached "state" of the state machine within the MoveNext method. We work with a copy of the state to avoid shared mutable state between threads. (Two threads can be executing in a Task's MoveNext method because an awaited task may complete after the awaiter has tested whether the subtask is complete but before the awaiter has returned) For each distinct label, the set of states that need to be dispatched to that label. Note that there is a dispatch occurring at every try-finally statement, so this variable takes on a new set of values inside each try block. A mapping from each state of the state machine to the new state that will be used to execute finally blocks in case the state machine is disposed. The Dispose method computes the new state and then runs MoveNext. A try block might have no state (transitions) within it, in which case it does not need to have a state to represent finalization. This field tells us whether the current try block that we are within has a finalizer state. If so it will hold on the syntax node associated with the try block. If is not Nothing, this is the state for finalization from anywhere in this try block. Initially set to -1, representing the no-op finalization required at the top level. The set of local variables and parameters that were hoisted and need a proxy. EnC support: the rewriter stores debug info for each await/yield in this builder. Implementation-specific name for labels to mark state machine resume points. Generate return statements from the state machine method body. Generates code that switches over states and jumps to the target labels listed in . If this is the outermost state dispatch switching over all states of the state machine - i.e. not state dispatch generated for a try-block. Must remain in sync with . Must remain in sync with . The try statement is the most complex part of the state machine transformation. Since the CLR will not allow a 'goto' into the scope of a try statement, we must generate the dispatch to the state's label stepwise. That is done by translating the try statements from the inside to the outside. Within a try statement, we start with an empty dispatch table (representing the mapping from state numbers to labels). During translation of the try statement's body, the dispatch table will be filled in with the data necessary to dispatch once we're inside the try block. We generate that at the head of the translated try statement. Then, we copy all of the states from that table into the table for the enclosing construct, but associate them with a label just before the translated try block. That way the enclosing construct will generate the code necessary to get control into the try block for all of those states. True if the initial values of locals in the rewritten method need to be preserved. (e.g. enumerable iterator methods) Type substitution if applicable or Nothing Add fields to the state machine class that control the state machine. Initialize the state machine class. Generate implementation-specific state machine initialization for the kickoff method body. Generate implementation-specific state machine member method implementations. If any required special/well-known type/member is not found or has use-site errors we should not continue with transformation because it may have unwanted consequences; e.g. we do return Nothing if well-known member symbol is not found. This method should check all required symbols and return False if any of them are missing or have use-site errors. We will also return True if signature is definitely bad - contains parameters that are ByRef or have error types Check that the property and its getter exist and collect any use-site errors. This class represents a type symbol for compiler generated implementation methods, the method being implemented is passed as a parameter and is used to build implementation method's parameters, return value type, etc... Represents a state machine MoveNext method. Handles special behavior around inheriting some attributes from the original async/iterator method. Represents a state machine method other than a MoveNext method. All such methods are considered non-user code. This class represents a symbol for the compiler generated property that owns implemented getter (like IEnumerable.Current), The getter method being implemented is passed as a parameter and is used to build implementation property around it with appropriate parameters, return value type, etc... Tracks synthesized fields that are needed in a submission being compiled. For every other submission referenced by this submission we add a field, so that we can access members of the target submission. A field is also needed for the host object, if provided. A helper class for synthesizing quantities of code. Code if the #If False out is code ported from C# that isn't currently used, and hence has no code coverage. It may or may not work correctly, but should be a useful starting point. Assignment expressions in lowered form should always have suppressObjectClone = True Check for (and assert that there are no) duplicate case labels in the switch. Synthesizes an expression that evaluates to the index portion of a method's metadata token. Synthesizes an expression that evaluates to the maximum value of the index portions of all method definition metadata tokens in current module. Synthesizes an expression that evaluates to the current module's MVID. Synthesizes an expression that evaluates to a text representation of the current module/s MVID. Synthesizes an expression that evaluates to the root of the dynamic analysis payloads for a particular kind of dynamic analysis. Uniquely identifies the kind of dynamic analysis. Type of an analysis payload cell for the particular analysis kind. Synthesizes an expression that evaluates to the index of a source document in the table of debug source documents. Given an expression that produces some result and has some observable evaluation side effects, return two expressions: 1) First - produces the same result with the same observable side effects, 2) Second - produces the same result, but without observable side effects, whenever possible. This is used for compound assignment, method call ByRef parameter copy back, etc. Expression to be used instead of With statement expression placeholder Locals being used Locals initialization expressions Given an expression specified for With statement produces: 1) Expression - an expression to be used instead of expression placeholder 2) Locals - a set of locals used to capture parts of Expression 3) Initializers - initializers for Locals To be used in With statement only! Represents the state of Option Strict checking. Option Strict is Off. No Option Strict checks are in effect. The Option Strict checks generate warnings. (Note that other compile options may hide these warnings, or turn them into errors.) Option Strict is On. All Option Strict checks are in effect and produce errors. This class is used to validate the compiler options. Parse the project level imports, adding errors to the errorBag as necessary Validate and parse the root namespace. If the root namespace string is a valid namespace name, the parsed version is returned. Otherwise Nothing is returned. Check if a string is a valid component of the root namespace. We use the usual VB identifier rules, but don't check for keywords (this is the same as previous versions). Adds predefined preprocessor symbols VBC_VER and TARGET to given list of preprocessor symbols if not included yet. The Output kind to derive the value of TARGET symbol from. A collection of KeyValue pairs representing existing symbols. Array of symbols that include VBC_VER and TARGET. Adds predefined preprocessor symbols VBC_VER and TARGET to given list of preprocessor symbols if not included yet. The Output kind to derive the value of TARGET symbol from. An parameter array of KeyValue pairs representing existing symbols. Array of symbols that include VBC_VER and TARGET. Adds predefined preprocessor symbols VBC_VER and TARGET to given list of preprocessor symbols if not included yet. The Output kind to derive the value of TARGET symbol from. An ImmutableArray of KeyValue pairs representing existing symbols. Array of symbols that include VBC_VER and TARGET. The possible reasons a symbol may be inaccessible Contains the code for determining VB accessibility rules. Checks if 'symbol' is accessible from within assembly 'within'. Checks if 'symbol' is accessible from within assembly 'within'. Checks if 'symbol' is accessible from within type 'within', with an optional qualifier of type "throughTypeOpt". Checks if 'symbol' is accessible from within type 'within', with a qualifier of type "throughTypeOpt". Sets "failedThroughTypeCheck" to true if it failed the "through type" check. Checks if 'symbol' is accessible from within 'within', which must be a NamedTypeSymbol or an AssemblySymbol. If 'symbol' is accessed off of an expression then 'throughTypeOpt' is the type of that expression. This is needed to properly do protected access checks. Sets "failedThroughTypeCheck" to true if this protected check failed. Determine if "derivedType" inherits from or implements "baseType", ignoring constructed types, and dealing only with original types. Captures information about illegal access exposure. The exposed type. Namespace or type that "gains" access to the type. Returns true if there is no illegal access exposure, false otherwise. Type or member exposing the type. The exposed type. If function returns false, it requests an instance of ArrayBuilder from the pool and populates it with information about illegal exposure. The caller is responsible for returning the ArrayBuilder to the pool. Returns true if there is no illegal access exposure, false otherwise. Determine if member is the definition of the type, or is contained (directly or indirectly) in the definition of the type. Returns true if there is no illegal access exposure, false otherwise. Four cases: 1: Member is not protected, non of its enclosing scopes are protected 2: Member is not protected, but some of its enclosing scopes are protected 3: Member is protected, non of its enclosing scopes are protected 4: Member is protected, some of its enclosing scopes are also protected Can type be accessed through container's inheritance? This function finds the inner most enclosing scope whose Access is lesser than or equal to the given access "StopAtAccess". Member - for which the enclosing scope has to be found the enclosing scope's access has to be lesser than Returns false if there were errors reported due to access exposure, true otherwise. Narrow a quadword result to a specific integral type, setting Overflow true if the result value cannot be represented in the result type. Summarizes whether a conversion is allowed, and if so, which kind of conversion (and in some cases, the associated symbol). Returns True if the conversion exists, either as a widening or narrowing conversion. If this returns True, exactly one of or will return True. If this returns False, neither or will return True. Returns True if this conversion a narrowing conversion, and not a widening conversion. Returns True if this conversion is a widening conversion, and not a narrowing conversion. Returns True if this conversion is an identity conversion. Note that identity conversion are also considered widening conversions. Returns True if this conversion is a default conversion (a conversion from the "Nothing" literal). Note that default conversions are considered widening conversions. Returns True if this conversion is a widening numeric conversion or a narrowing numeric conversion, as defined in section 8.3. Returns True if this conversion is a narrowing boolean conversion, as defined in section 8.2. Returns True if this conversion is a widening reference conversion or narrowing reference conversion, as defined in section 8.4. Returns True if this conversion is a widening anonymous delegate conversion as defined in section 8.8, or a narrowing anonymous delegate conversion as defined in section 8.9. Returns True if this is a lambda conversion. Returns True if this conversion is a widening array conversion or a narrowing array conversion, as defined in section 8.5. Returns True if this conversion a widening value type conversion or a narrowing value type conversion as defined in section 8.6. Returns True if this conversion a widening nullable value type conversion or a narrowing nullable value type conversion as defined in section 8.6.1. Returns True if this conversion a widening string conversion or a narrowing string conversion as defined in section 8.7. Returns True if this conversion a widening type parameter or a narrowing type parameter conversion, as defined in section 8.10. Returns True if this conversion a widening user defined or a narrowing user defined conversion, as defined in section 8.11. If this returns True, the involved conversion method can be obtained with the property. Returns the method that defines the user defined conversion, if any. Otherwise returns Nothing. Returns True if two values are equal. The left value. The right value. Returns True if two values are not equal. The left value. The right value. Creates a from this Visual Basic conversion. The that represents this conversion. This is a lossy conversion; it is not possible to recover the original from the struct. Determines whether the specified object is equal to the current object. The object to compare with the current object. Determines whether the specified object is equal to the current object. The object to compare with the current object. Returns a hash code for the current object. Returns a string that represents the current object. Because flags can be combined, use the method IsIdentityConversion when testing for ConversionKind.Identity Can be combined with to indicate that the underlying value conversion is a predefined tuple conversion Can be combined with to indicate that the underlying value conversion is a predefined tuple conversion The purpose of this class is to answer questions about convertibility of one type to another. It also answers questions about conversions from an expression to a type. The code is organized such that each method attempts to implement exactly one section of the specification. Attempts to fold conversion of a constant expression. Returns Nothing if conversion cannot be folded. If conversion failed due to non-integer overflow, ConstantValue.Bad is returned. Consumer is responsible for reporting appropriate diagnostics. If integer overflow occurs, integerOverflow is set to True and ConstantValue for overflowed result is returned. Consumer is responsible for reporting appropriate diagnostics and potentially discarding the result. Attempts to fold conversion of a constant expression. Returns Nothing if conversion cannot be folded, i.e. unexpected source and destination types. Returns Bad value (Discriminator = ConstantValueTypeDiscriminator.Bad) if conversion failed due to non-integer overflow. If integer overflow occurs, integerOverflow is set to True and the overflowed result is returned. This function classifies all intrinsic language conversions and user-defined conversions. This function classifies all intrinsic language conversions, such as inheritance, implementation, array covariance, and conversions between intrinsic types. This function classifies all intrinsic language conversions and user-defined conversions. Reclassify lambdas, array literals, etc. This function classifies user-defined conversions between two types. This function classifies user-defined conversions. This function classifies all intrinsic language conversions, such as inheritance, implementation, array covariance, and conversions between intrinsic types. Helper structure to classify conversions from named types to interfaces in accumulating fashion. Accumulates classification information about conversion to interface. Returns True when classification gets promoted to Identity, this method should not be called after that. Returns when classification gets promoted to Identity. Returns true if and only if baseType is a base class of derivedType. Derived class type. Target base class type. Calculate MethodConversionKind based on required return type conversion. TODO: It looks like Dev10 MethodConversionKinds for return are badly named because they appear to give classification in the direction opposite to the data flow. This is very confusing. However, I am not going to rename them just yet. Will do this when all parts are ported and working together, otherwise it will be very hard to port the rest of the feature. We are trying to classify conversion between methods ConvertFrom(...) As returnTypeOfConvertFromMethod -> ConvertTo(...) As returnTypeOfConvertToMethod The relaxation stub would look like: Stub(...) As returnTypeOfConvertToMethod Return ConvertFrom(...) End ... Returns the methods conversions for the given conversion kind We are trying to classify conversion between methods arguments delegateInvoke(parameterConvertFrom) -> targetMethod(parameterConvertTo) The relaxation stub would look like (stub has same signature as delegate invoke): Stub(parameterConvertFrom) return targetMethod(parameterConvertTo) End Method The conversion. The delegate parameter type. Will set only bits used for delegate relaxation level. Determine the relaxation level of a given conversion. This will be used by overload resolution in case of conflict. This is to prevent applications that compiled in VB8 to fail in VB9 because there are more matches. And the same for flipping strict On to Off. Will set only bits used for delegate relaxation level. Determines whether a stub needed for the delegate creations conversion based on the given method conversions. The method conversions. true if a stub needed for conversion; otherwise, false. Tells whether the method conversion is considered to be narrowing or not. Determines whether the given conversion is CLR supported conversion or not. The conversion. true if the given conversion is a CLR supported conversion; otherwise, false. Used by ClassifyUserDefinedConversion to pass an ArrayTypeSymbol that has a link back to the BoundArrayLiteral node. This allows the ClassifyConversionOperatorInOutConversions to properly classify a conversion from the inferred array type to the input type of a user defined conversion. Create a new ArrayTypeSymbol. A map from Operator name to number of parameters and kind. Operator kind and expected number of parameters. Returns UnaryOperatorKind.Error in case of error, otherwise adjusted operator kind. Returns result type of the operator or SpecialType.None if operator is not supported. Attempts to fold unary operator applied to a constant expression. Returns Nothing if operator cannot be folded. If folding failed due to non-integer overflow, ConstantValue.Bad is returned. Consumer is responsible for reporting appropriate diagnostics. If integer overflow occurs, integerOverflow is set to True and ConstantValue for overflowed result is returned. Consumer is responsible for reporting appropriate diagnostics and potentially discarding the result. Returns UnaryOperatorKind.Error in case of error, otherwise adjusted operator kind. For comparison operators, the operator type computed here is not the result type of the comparison (which is typically boolean), but is the type to which the operands are to be converted. For other operators, the type computed here is both the result type and the common operand type. Attempts to fold binary operator applied to constant expressions. Returns Nothing if operator cannot be folded. If folding failed due to non-integer overflow or divide by zero, ConstantValue.Bad is returned. Consumer is responsible for reporting appropriate diagnostics. If divide by zero occurs, divideByZero is set to True. If integer overflow occurs, integerOverflow is set to True and ConstantValue for overflowed result is returned. Consumer is responsible for reporting appropriate diagnostics and potentially discarding the result. Returns ConstantValue.Bad if, and only if, compound string length is out of supported limit. Returns result type of the operator or SpecialType.None if operator is not supported. Returns True if resolution of user defined conversions is complete, i.e. there were operators applicable for the "Most Specific Widening Conversion" purposes. This, however, doesn't mean that resolution is successful. Returns false if operator should be ignored. Returns True if resolution of user defined conversions is complete, i.e. there was an operator that converts from the most specific source type to the most specific target type. This, however, doesn't mean that resolution is successful. The most encompassed type in a set of types is the one type that is encompassed by all other types in the set. If no single type is encompassed by all other types, then the set has no most encompassed type. In intuitive terms, the most encompassed type is the "smallest" type in the set—the one type that can be converted from each of the other types through a narrowing conversion. The most encompassing type in a set of types is the one type that encompasses all other types in the set. If no single type encompasses all other types, then the set has no most encompassing type. In intuitive terms, the most encompassing type is the "largest" type in the set—the one type to which each of the other types can be converted through a widening conversion. Returns number of types in the list of {input type, output type} that refer to a generic type parameter. A quick check whether given conversion operator is a widening operator. Collect user-defined conversion operators. Operators declared in the same type are grouped together. Within a group, widening operators are followed by narrowing operators. Collect user-defined operators. Operators declared in the same type are grouped together. Within a group, name1 operators are followed by name2 operators. Returns True if we should stop climbing inheritance hierarchy. Given the type of operator's argument, return corresponding type to look for operator in. Can return Nothing. Information about a candidate from a group. Will have different implementation for methods, extension methods and properties. Whether the method is used as extension method vs. called as a static method. Whether the method is used as an operator. Whether the method is used in a lifted to nullable form. Precedence level for an extension method. Extension method type parameters that were fixed during currying, if any. If none were fixed, BitArray.Null should be returned. Receiver type for extension method. Otherwise, containing type. For extension methods, the type of the fist parameter in method's definition (i.e. before type parameters are substituted). Otherwise, same as the ReceiverType. Implementation for an ordinary method (based on usage). Implementation for an extension method, i.e. it is used as an extension method. Implementation for an operator Implementation for a lifted operator. Implementation for a property. Only bits specific to delegate relaxation level are returned. This might simplify error reporting. If not, consider getting rid of this property. Perform overload resolution on the given method or property group, with the given arguments and names. The names can be null if no names were supplied to any arguments. Perform overload resolution on the given method group, with the given arguments. Perform overload resolution on the given method group, with the given arguments and names. The names can be null if no names were supplied to any arguments. Perform overload resolution on the given array of property symbols. Given instance method candidates gone through applicability analysis, figure out if we should consider extension methods, if any. §11.8.1 Overloaded Method Resolution 6. Next, if, given any two members of the set, M and N, M is more applicable than N to the argument list, eliminate N from the set. If more than one member remains in the set and the remaining members are not equally applicable to the argument list, a compile-time error results. 7. Otherwise, given any two members of the set, M and N, apply the following tie-breaking rules, in order. Returns amount of applicable candidates left. Note that less applicable candidates are going to be eliminated if and only if there are most applicable candidates. Returns amount of applicable candidates left. Returns True if there are most applicable candidates. indexesOfMostApplicableCandidates will contain indexes of equally applicable candidates, which are most applicable by comparison to the other (non-equal) candidates. The indexes will be in ascending order. §11.8.1 Overloaded Method Resolution 7. Otherwise, given any two members of the set, M and N, apply the following tie-breaking rules, in order. §11.8.1 Overloaded Method Resolution 7. Otherwise, given any two members of the set, M and N, apply the following tie-breaking rules, in order. Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.10. If the overload resolution is being done to resolve the target of a delegate-creation expression from an AddressOf expression and M is a function, while N is a subroutine, eliminate N from the set. Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.8. If one or more arguments are AddressOf or lambda expressions, and all of the corresponding delegate types in M match exactly, but not all do in N, eliminate N from the set. 7.9. If one or more arguments are AddressOf or lambda expressions, and all of the corresponding delegate types in M are widening conversions, but not all are in N, eliminate N from the set. Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.9. If M did not use any optional parameter defaults in place of explicit arguments, but N did, then eliminate N from the set. !!!WARNING!!! The index (7.9) is based on "VB11 spec [draft 3]" version of documentation rather than Dev10 documentation. TODO: Update indexes of other overload method resolution rules Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.7. If M and N both required type inference to produce type arguments, and M did not require determining the dominant type for any of its type arguments (i.e. each the type arguments inferred to a single type), but N did, eliminate N from the set. §11.8.1.1 Applicability §11.8.1.1 Applicability This method groups equally applicable (§11.8.1.1 Applicability) candidates into buckets. Returns an ArrayBuilder of buckets. Each bucket is represented by an ArrayBuilder(Of Integer), which contains indexes of equally applicable candidates from input parameter 'candidates'. §11.8.1 Overloaded Method Resolution 3. Next, eliminate all members from the set that require narrowing conversions to be applicable to the argument list, except for the case where the argument expression type is Object. 4. Next, eliminate all remaining members from the set that require narrowing coercions to be applicable to the argument list. If the set is empty, the type containing the method group is not an interface, and strict semantics are not being used, the invocation target expression is reclassified as a late-bound method access. Otherwise, the normal rules apply. Returns amount of applicable candidates left. §11.8.1 Overloaded Method Resolution 2. Next, eliminate all members from the set that are inaccessible or not applicable to the argument list. Note, similar to Dev10 compiler this process will eliminate candidates requiring narrowing conversions if strict semantics is used, exception are candidates that require narrowing only from numeric constants. Returns amount of applicable candidates left. Figure out corresponding arguments for parameters §11.8.2 Applicable Methods. Note, this function mutates the candidate structure. If non-Nothing ArrayBuilders are returned through parameterToArgumentMap and paramArrayItems parameters, the caller is responsible fo returning them into the pool. Assumptions: 1) This function is never called for a candidate that should be rejected due to parameter count. 2) Omitted arguments [ Call Goo(a, , b) ] are represented by OmittedArgumentExpression node in the arguments array. 3) Omitted argument never has name. 4) argumentNames contains Nothing for all positional arguments. !!! Should keep this function in sync with Binder.PassArguments, which uses data this function populates. !!! !!! Should keep this function in sync with Binder.ReportOverloadResolutionFailureForASingleCandidate. !!! !!! Everything we flag as an error here, Binder.ReportOverloadResolutionFailureForASingleCandidate should detect as well. !!! Match candidate's parameters to arguments §11.8.2 Applicable Methods. Note, similar to Dev10 compiler this process will eliminate candidate requiring narrowing conversions if strict semantics is used, exception are candidates that require narrowing only from numeric constants. Assumptions: 1) This function is never called for a candidate that should be rejected due to parameter count. 2) Omitted arguments [ Call Goo(a, , b) ] are represented by OmittedArgumentExpression node in the arguments array. 3) Omitted argument never has name. 4) argumentNames contains Nothing for all positional arguments. !!! Should keep this function in sync with Binder.PassArguments, which uses data this function populates. !!! !!! Should keep this function in sync with Binder.ReportOverloadResolutionFailureForASingleCandidate. !!! !!! Should keep this function in sync with InferenceGraph.PopulateGraph. !!! !!! Everything we flag as an error here, Binder.ReportOverloadResolutionFailureForASingleCandidate should detect as well. !!! Should be in sync with Binder.ReportByRefConversionErrors. Should be in sync with Binder.ReportByValConversionErrors. Performs an initial pass through the group of candidates and does the following in the process. 1) Eliminates candidates based on the number of supplied arguments and number of supplied generic type arguments. 2) Adds additional entries for expanded ParamArray forms when applicable. 3) Infers method's generic type arguments if needed. 4) Substitutes method's generic type arguments. 5) Eliminates candidates based on shadowing by signature. This partially takes care of §11.8.1 Overloaded Method Resolution, section 7.1. If M is defined in a more derived type than N, eliminate N from the set. 6) Eliminates candidates with identical virtual signatures by applying various shadowing and tie-breaking rules from §11.8.1 Overloaded Method Resolution, section 7.0 • If M has fewer parameters from an expanded paramarray than N, eliminate N from the set. 7) Takes care of unsupported overloading within the same type for instance methods/properties. Assumptions: 1) Shadowing by name has been already applied. 2) group can include extension methods. 3) group contains original definitions, i.e. method type arguments have not been substituted yet. Exception are extension methods with type parameters substituted based on receiver type rather than based on type arguments supplied at the call site. 4) group contains only accessible candidates. 5) group doesn't contain members involved into unsupported overloading, i.e. differ by casing or custom modifiers only. 6) group does not contain duplicates. 7) All elements of arguments array are Not Nothing, omitted arguments are represented by OmittedArgumentExpression node. This method is destructive to content of the [group] parameter. Combine new candidate with the list of existing candidates, applying various shadowing and tie-breaking rules. New candidate may or may not be added to the result, some existing candidates may be removed from the result. Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.5. If M is not an extension method and N is, eliminate N from the set. 7.6. If M and N are extension methods and M was found before N, eliminate N from the set. Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.4. If M is less generic than N, eliminate N from the set. Implements shadowing based on §11.8.1.3 Depth of genericity False if node of candidates wins Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.3. If M and N are extension methods and the target type of M has fewer type parameters than the target type of N, eliminate N from the set. !!! Note that spec talks about "fewer type parameters", but it is not really about count. !!! It is about one refers to a type parameter and the other one doesn't. Implements shadowing based on §11.8.1 Overloaded Method Resolution. 7.1. If M is defined in a more derived type than N, eliminate N from the set. This rule also applies to the types that extension methods are defined on. 7.2. If M and N are extension methods and the target type of M is a class or structure and the target type of N is an interface, eliminate N from the set. For a receiver to match an instance, more or less, the type of that instance has to be convertible to the type of the receiver with the same bit-representation (i.e. identity on value-types and reference-convertibility on reference types). Actually, we don't include the reference-convertibilities that seem nonsensical, e.g. enum() to underlyingtype() We do include inheritance, implements and variance conversions amongst others. Implements shadowing based on §11.8.1 Overloaded Method Resolution. • If M has fewer parameters from an expanded paramarray than N, eliminate N from the set. This class walks all the statements in some syntax, in order, except those statements that are contained inside expressions (a statement can occur inside an expression if it is inside a lambda.) This is used when collecting the declarations and declaration spaces of a method body. Typically the client overrides this class and overrides various Visit methods, being sure to always delegate back to the base. The only public entry point is the Infer method. Returns True if the inference algorithm should be restarted. Returns False if the search should be cancelled. Returns False if the search should be cancelled. Returns first Or a modified version Of first With common tuple names from both types. This class associates a symbol with particular custom format for display. It can be passed as an argument for an error message in place where symbol display should go, which allows to defer building strings and doing many other things (like loading metadata) associated with that until the error message is actually requested. Displays a value in the VisualBasic style. Returns a string representation of an object of primitive type. A value to display as a string. Options used to customize formatting of an Object value. A string representation of an object of primitive type (or null if the type is not supported). Handles , , , , , , , , , , , , , , and Nothing. Formats string literal. Literal value. Options used to customize formatting of a literal value. Displays a symbol in the VisualBasic style. Displays a symbol in the Visual Basic style, based on a . The symbol to be displayed. The formatting options to apply. If Nothing is passed, will be used. A formatted string that can be displayed to the user. The return value is not expected to be syntactically valid Visual Basic. Displays a symbol in the Visual Basic style, based on a . Based on the context, qualify type And member names as little as possible without introducing ambiguities. The symbol to be displayed. Semantic information about the context in which the symbol is being displayed. A position within the Or . The formatting options to apply. If null is passed, will be used. A formatted string that can be displayed to the user. The return value is not expected to be syntactically valid Visual Basic. Convert a symbol to an array of string parts, each of which has a kind. Useful for colorizing the display string. The symbol to be displayed. The formatting options to apply. If Nothing Is passed, will be used. A list of display parts. Parts are not localized until they are converted to strings. Convert a symbol to an array of string parts, each of which has a kind. Useful for colorizing the display string. The symbol to be displayed. Semantic information about the context in which the symbol is being displayed. A position within the or . The formatting options to apply. If null is passed, will be used. A list of display parts. Parts are not localized until they are converted to strings. Returns a string representation of an object of primitive type. A value to display as a string. Whether or not to quote string literals. Whether or not to display integral literals in hexadecimal. A string representation of an object of primitive type (or null if the type is not supported). Handles , , , , , , , , , , , , , , and Nothing. Returns true if tuple type syntax can be used to refer to the tuple type without loss of information. For example, it cannot be used when extension tuple is using non-default friendly names. Return the number of special constraints ('Class', 'Structure', and 'New') associated with the type parameter. Append a default argument (i.e. the default argument of an optional parameter). Assumed to be non-null. represents a single item in Handles list. Kind of Handles event container. (Me, MyBase, MyClass or a WithEvents variable) Symbol for the event handled in current Handles item. Kind of a Handles item represented by a HandledEvent Handles Me.Event1 Handles MyClass.Event1 Handles MyBase.Event1 Handles SomeWithEventsVariable.Event1 Virtual dispatch based on a symbol's particular class. Result type Additional argument type Call the correct VisitXXX method in this class based on the particular type of symbol that is passed in. Returns the System.String that represents the current TypedConstant. A System.String that represents the current TypedConstant. This is a SyntaxReference implementation that lazily finds the beginning of the block (if any) of the original syntax reference Returns true if the specified node represents a lambda. Given a node that represents a lambda body returns a node that represents the lambda. SyntaxNode.GetCorrespondingLambdaBody(SyntaxNode) We need to handle case when an old node that represents a lambda body with multiple nodes of the same kind is mapped to a new node that belongs to the lambda body but is different from the one that represents the new body. In that case isn't lambda representing node (the first range variable of a clause) but its equivalent peer (another range variable of the same clause). Returns true if the specified represents a body of a lambda. Returns true if the specified is part of a lambda body and its parent is not. Returns the node () that represents the containing lambda body. VB lambda bodies may be non-contiguous sequences of nodes whose ancestor (parent or grandparent) is a lambda node. Whenever we need to check whether a node is a lambda body node we should use this method. If the specified node represents a lambda returns a node (or nodes) that represent its body (bodies). Enumerates all nodes that belong to the given and their parents do not (they are the top-most expressions and statements of the body). If the specified node represents a "simple" lambda returns a node (or nodes) that represent its body (bodies). Lambda is "simple" if all its body nodes are also its child nodes and vice versa. Compares content of two nodes ignoring lambda bodies and trivia. Non-user code lambdas are synthesized lambdas that create an instance of an anonymous type representing a pair of values, or otherwise transform sequences/anonymous types from one form to another without calling user code. TODO: Could we avoid generating proper lambdas for these? Returns true if the specified node can represent a closure scope -- that is a scope of a captured variable. Doesn't validate whether or not the node actually declares any captured variable. this is a SyntaxReference implementation that lazily translates the result (SyntaxNode) of the original syntax reference to other one. Returns the TypeSyntax of the given NewExpressionSyntax if specified. Returns the TypeSyntax of the given AsClauseSyntax if specified. Returns the AttributeBlockSyntax of the given AsClauseSyntax if specified. Updates the given SimpleNameSyntax node with the given identifier token. This function is a wrapper that calls WithIdentifier on derived syntax nodes. The given simple name updated with the given identifier. Given an initializer expression infer the name of anonymous property or tuple element. Returns Nothing if unsuccessful Enumeration with all Visual Basic syntax node kinds. A class to represent an empty statement. This can occur when a colon is on a line without anything else. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an "End XXX" statement, where XXX is a single keyword. Represents an entire source file of VB code. Represents an Option statement, such as "Option Strict On". Represents an Imports statement, which has one or more imports clauses. Represents the clause of an Imports statement that imports all members of a type or namespace or aliases a type or namespace. Defines a XML namespace for XML expressions. Represents a Namespace statement, its contents and the End Namespace statement. Represents the beginning statement of a namespace declaration. This node always appears as the Begin of a BlockStatement with Kind=NamespaceBlock. Represents a declaration of Module, its contents and the End statement that ends it. Represents a declaration of a Structure, its contents and the End statement that ends it. Represents a declaration of a Interface, its contents and the End statement that ends it. Represents a declaration of a Class its contents and the End statement that ends it. Represents a declaration of an Enum, its contents and the End Enum statement that ends it. Represents an Inherits statement in a Class, Structure or Interface. Represents an Implements statement in a Class or Structure. Represents the beginning statement of a Module declaration. This node always appears as the Begin of a TypeBlock with Kind=ModuleDeclarationBlock. Represents the beginning statement of a Structure declaration. This node always appears as the Begin of a TypeBlock with Kind=StructureDeclarationBlock. Represents the beginning statement of a Interface declaration. This node always appears as the Begin of a TypeBlock with Kind=InterfaceDeclarationBlock. Represents the beginning statement of a Class declaration. This node always appears as the Begin of a TypeBlock with Kind=ClassDeclarationBlock. Represents the beginning statement of an Enum declaration. This node always appears as the Begin of an EnumBlock with Kind=EnumDeclarationBlock. Represents the type parameter list in a declaration. Represents a type parameter on a generic type declaration. One of the type parameter constraints clauses. This represents a constraint clause in the form of "As Constraint". One of the type parameter constraints clauses. This represents a constraint clause in the form of "As { Constraints }". One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. One of the special type parameter constraints: New, Class or Structure. Which kind of special constraint it is can be obtained from the Kind property and is one of: NewConstraint, ReferenceConstraint or ValueConstraint. Represents a type parameter constraint that is a type. Represents a name and value in an EnumDeclarationBlock. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Represents a Function or Sub block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Represents a constructor block declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Represents an Operator block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. Represents an accessor block member declaration: A declaration that has a beginning declaration, a body of executable statements and an end statement. Examples include property accessors and custom event accessors. Represents a block property declaration: A declaration that has a beginning declaration, some get or set accessor blocks and an end statement. Represents a custom event declaration: A declaration that has a beginning event declaration, some accessor blocks and an end statement. Represents the parameter list in a method declaration. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. The statement that declares a Sub or Function. If this method has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A statement that declares a constructor. This statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. A Declare statement that declares an external DLL method. A Declare statement that declares an external DLL method. A statement that declares a delegate type. A statement that declares a delegate type. A statement that declares an event. If the event being declared is a custom event, this statement will be the Begin of a PropertyOrEventBlock, and the accessors will be part of the Accessors of that node. A statement that declares an operator. If this operator has a body, this statement will be the Begin of a BlockStatement with Kind=MethodDeclarationBlock, and the body of the method will be the Body of that BlockStatement. Statement that declares a property. If this property has accessors declared, this statement will be the Begin of a BlockNode, and the accessors will be the Body of that node. Auto properties are property declarations without a PropertyBlock. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents a Get or Set accessor on a property declaration or an AddHandler, RemoveHandler or RaiseEvent accessor on a custom event declaration. The Kind of the node determines what kind of accessor this is. This statement is always the Begin of a BlockNode, and the body of the accessor is the Body of that node. Represents the "Implements ..." clause on a type member, which describes which interface members this member implements. Represents the "Handles ..." clause on a method declaration that describes which events this method handles. Represents event container specified through special keywords "Me", "MyBase" or "MyClass".. Represents event container that refers to a WithEvents member. Represents event container that refers to a WithEvents member's property. Represents a single handled event in a "Handles ..." clause. Represents the beginning of a declaration. However, not enough syntax is detected to classify this as a field, method, property or event. This is node always represents a syntax error. Represents the declaration of one or more variables or constants, either as local variables or as class/structure members. In the case of a constant, it is represented by having "Const" in the Modifiers (although technically "Const" is not a modifier, it is represented as one in the parse trees.) Represents the part of a variable or constant declaration statement that associated one or more variable names with a type. Represents an "As {type-name}" clause that does not have an initializer or "New". The type has optional attributes associated with it, although attributes are not permitted in all possible places where this node occurs. Represents an "As New {type-name} [arguments] [initializers]" clause in a declaration. The type has optional attributes associated with it, although attributes are not permitted in many places where this node occurs (they are permitted, for example, on automatically implemented properties.) Represents a "With {...} clause used to initialize a new object's members. Represents a "From {...} clause used to initialize a new collection object's elements. Represent a field initializer in a With {...} initializer where the field name is inferred from the initializer expression. Represent a named field initializer in a With {...} initializer, such as ".x = expr". Represents an "= initializer" clause in a declaration for a variable, parameter or automatic property. Represent a parameter to a method, property, constructor, etc. Represents an identifier with optional "?" or "()" or "(,,,)" modifiers, as used in parameter declarations and variable declarations. Represents a modifier that describes an array type, without bounds, such as "()" or "(,)". Represents a group of attributes within "<" and ">" brackets. Represents a single attribute declaration within an attribute list. Represents a single attribute declaration within an attribute list. Represents a file-level attribute, in which the attributes have no other syntactic element they are attached to. Represent an expression in a statement context. This may only be a invocation or await expression in standard code but may be any expression in VB Interactive code. Represent a "? expression" "Print" statement in VB Interactive code. Represents a While...End While statement, including the While, body and End While. Represents an entire Using...End Using statement, including the Using, body and End Using statements. Represents a entire SyncLock...End SyncLock block, including the SyncLock statement, the enclosed statements, and the End SyncLock statement. Represents a With...End With block, include the With statement, the body of the block and the End With statement. Represents the declaration of one or more local variables or constants. Represents a label statement. Represents a "GoTo" statement. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. A label for a GoTo, Resume, or On Error statement. An identifier, line number, or next keyword. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. Represents a "Stop" or "End" statement. The Kind can be used to determine which kind of statement this is. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. An exit statement. The kind of block being exited can be found by examining the Kind. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. Represents a "Continue (block)" statement. THe kind of block referenced can be determined by examining the Kind. Represents a "Return" statement. Represents a line If-Then-Else statement. Represents part of a single line If statement, consisting of a beginning if-statement, followed by a body of statement controlled by that beginning statement. The Kind property returns if this is a SingleLineIf. Represents the Else part of an If statement, consisting of a Else statement, followed by a body of statement controlled by that Else. Represents a block If...Then...Else...EndIf Statement. The Kind property can be used to determine if it is a block or line If. Represents part of an If statement, consisting of a beginning statement (If or ElseIf), followed by a body of statement controlled by that beginning statement. The Kind property returns if this is an If or ElseIf. Represents the Else part of an If statement, consisting of a Else statement, followed by a body of statement controlled by that Else. Represents the If part or ElseIf part of a If...End If block (or line If). This statement is always the Begin of a IfPart. The Kind can be examined to determine if this is an If or an ElseIf statement. Represents the If part or ElseIf part of a If...End If block (or line If). This statement is always the Begin of a IfPart. The Kind can be examined to determine if this is an If or an ElseIf statement. Represents the Else part of a If...End If block (or line If). This statement is always the Begin of a ElsePart. Represents an entire Try...Catch...Finally...End Try statement. Represents a Catch part of a Try...Catch...Finally...End Try statement, consisting of a Catch statement, followed by a body of statements controlled by that Catch statement. The Kind property returns which kind of part this is. Represents the Finally part of a Try...Catch...Finally...End Try statement, consisting of a Finally statement, followed by a body of statements controlled by the Finally. Represents the Try part of a Try...Catch...Finally...End Try. This statement is always the Begin of a TryPart. Represents the Catch part of a Try...Catch...Finally...End Try. This statement is always the Begin of a CatchPart. Represents the When/Filter clause of a Catch statement Represents the Finally part of a Try...Catch...Finally...End Try. This statement is always the Begin of a FinallyPart. Represents the "Error" statement. Represents an OnError Goto statement. Represents an OnError Goto statement. Represents an OnError Goto statement. Represents an OnError Resume Next statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. Represents a "Resume" statement. The Kind property can be used to determine if this is a "Resume", "Resume Next" or "Resume label" statement. Represents a Select Case block, including the Select Case that begins it, the contains Case blocks and the End Select. Represents a Select Case statement. This statement always occurs as the Begin of a SelectBlock. Represents a case statement and its subsequent block. Represents a case statement and its subsequent block. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. Represents a Case or Case Else statement. This statement is always the Begin of a CaseBlock. If this is a Case Else statement, the Kind=CaseElse, otherwise the Kind=Case. The "Else" part in a Case Else statement. Represents a single value in a Case. Represents a range "expression To expression" in a Case. Represents a relation clause in a Case statement, such as "Is > expression". Represents a relation clause in a Case statement, such as "Is > expression". Represents a relation clause in a Case statement, such as "Is > expression". Represents a relation clause in a Case statement, such as "Is > expression". Represents a relation clause in a Case statement, such as "Is > expression". Represents a relation clause in a Case statement, such as "Is > expression". Represents the "SyncLock" statement. This statement always occurs as the Begin of a SyncLockBlock. Represents a For or For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). Represents a For or For Each block, including the introducing statement, the body and the "Next" (which can be omitted if a containing For has a Next with multiple variables). The For statement that begins a For-Next block. This statement always occurs as the Begin of a ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The Step clause in a For Statement. The For Each statement that begins a For Each-Next block. This statement always occurs as the Begin of a ForBlock, and the body of the For Each-Next is the Body of that ForBlock. Most of the time, the End of that ForBlock is the corresponding Next statement. However, multiple nested For statements are ended by a single Next statement with multiple variables, then the inner For statements will have End set to Nothing, and the Next statement is the End of the outermost For statement that is being ended. The Next statement that ends a For-Next or For Each-Next block. This statement always occurs as the End of a ForBlock (with Kind=ForBlock or ForEachBlock), and the body of the For-Next is the Body of that ForBlock. The Begin of that ForBlock has the corresponding For or For Each statement. The Using statement that begins a Using block. This statement always occurs as the Begin of a UsingBlock, and the body of the Using is the Body of that UsingBlock. Represents a Throw statement. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a simple, compound, or Mid assignment statement. Which one can be determined by checking the Kind. Represents a left-hand side of a MidAssignment statement. Represent a call statement (also known as a invocation statement). Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. Represents an AddHandler or RemoveHandler statement. The Kind property determines which one. Represent a RaiseEvent statement. Represents a "With" statement. This statement always occurs as the BeginStatement of a WithBlock, and the body of the With is the Body of that WithBlock. Represents a ReDim statement. Represents a ReDim statement. Represents a ReDim statement clause. Represents an "Erase" statement. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a literal. The kind of literal is determined by the Kind property: IntegerLiteral, CharacterLiteral, BooleanLiteral, DecimalLiteral, FloatingLiteral, DateLiteral or StringLiteral. The value of the literal can be determined by casting the associated Token to the correct type and getting the value from the token. Represents a parenthesized expression. Identifies the special instance "Me" Identifies the special instance "MyBase" Identifies the special instance "MyClass" Represents a GetType expression. Represents a TypeOf...Is or IsNot expression. Represents a TypeOf...Is or IsNot expression. Represents a GetXmlNamespace expression. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. Represents member access (.name) or dictionary access (!name). The Kind property determines which kind of access. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. Represents an XML member element access (node.<Element>), attribute access (node.@Attribute) or descendants access (node...<Descendant>). The Kind property determines which kind of access. Represents an invocation expression consisting of an invocation target and an optional argument list or an array, parameterized property or object default property index. Represents a New expression that creates a new non-array object, possibly with a "With" or "From" clause. Represents a New expression that create an object of anonymous type. Represents an expression that creates a new array. Represents an expression that creates a new array without naming the element type. Represents a cast to a pre-defined type using a pre-defined cast expression, such as CInt or CLng. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Represents a binary operator. The Kind property classifies the operators into similar kind of operators (arithmetic, relational, logical or string); the exact operation being performed is determined by the Operator property. Describes a unary operator: Plus, Negate, Not or AddressOf. Describes a unary operator: Plus, Negate, Not or AddressOf. Describes a unary operator: Plus, Negate, Not or AddressOf. Describes a unary operator: Plus, Negate, Not or AddressOf. Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). Represents a conditional expression, If(condition, true-expr, false-expr) or If(expr, nothing-expr). Represents a single line lambda expression. Represents a single line lambda expression. Represents a multi-line lambda expression. Represents a multi-line lambda expression. Represents the header part of a lambda expression Represents the header part of a lambda expression Represents a parenthesized argument list. Represents an omitted argument in an argument list. An omitted argument is not considered a syntax error but a valid case when no argument is required. Represents an argument that is just an optional argument name and an expression. Represents a range argument, such as "0 to 5", used in array bounds. The "Value" property represents the upper bound of the range. This class represents a query expression. A query expression is composed of one or more query operators in a row. The first query operator must be a From or Aggregate. Describes a single variable of the form "x [As Type] In expression" for use in query expressions. Describes a single variable of the form "[x [As Type] =] expression" for use in query expressions. Describes a single variable of the form "[x [As Type] =] aggregation-function" for use in the Into clause of Aggregate or Group By or Group Join query operators. Represents the name and optional type of an expression range variable. Represents an invocation of an Aggregation function in the aggregation range variable declaration of a Group By, Group Join or Aggregate query operator. Represents the use of "Group" as the aggregation function in the in the aggregation range variable declaration of a Group By or Group Join query operator. Represents a "From" query operator. If this is the beginning of a query, the Source will be Nothing. Otherwise, the Source will be the part of the query to the left of the From. Represents a "Let" query operator. Represents an Aggregate query operator. Represents the "Distinct" query operator. Represents a "Where" query operator. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. Represents a "Skip While" or "Take While" query operator. The Kind property tells which. Represents a "Skip" or "Take" query operator. The Kind property tells which. Represents a "Skip" or "Take" query operator. The Kind property tells which. Represents the "Group By" query operator. Represents the "expression Equals expression" condition in a Join. Represents a Join query operator. Represents the "Group Join" query operator. Represents the "Order By" query operator. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. An expression to order by, plus an optional ordering. The Kind indicates whether to order in ascending or descending order. Represents the "Select" query operator. Represents an XML Document literal expression. Represents the XML declaration prologue in an XML literal expression. Represents an XML document prologue option - version, encoding, standalone or whitespace in an XML literal expression. Represents an XML element with content in an XML literal expression. Represents Xml text. Represents the start tag of an XML element of the form <element>. Represents the end tag of an XML element of the form </element>. Represents an empty XML element of the form <element /> Represents an XML attribute in an XML literal expression. Represents a string of XML characters embedded as the content of an XML element. Represents an XML name of the form 'name' appearing in GetXmlNamespace(). Represents an XML name of the form 'name' or 'namespace:name' appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML name of the form <xml-name> appearing in source as part of an XML literal or member access expression or an XML namespace import clause. Represents an XML namespace prefix of the form 'prefix:' as in xml:ns="". Represents an XML comment of the form <!-- Comment --> appearing in an XML literal expression. Represents an XML processing instruction of the form '<? XMLProcessingTarget XMLProcessingValue ?>'. Represents an XML CDATA section in an XML literal expression. Represents an embedded expression in an XML literal e.g. '<name><%= obj.Name =%></name>'. Represents an array type, such as "A() or "A(,)", without bounds specified for the array. A type name that represents a nullable type, such as "Integer?". Represents an occurrence of a Visual Basic built-in type such as Integer or String in source code. Represents a type name consisting of a single identifier (which might include brackets or a type character). Represents a simple type name with one or more generic arguments, such as "X(Of Y, Z). Represents a qualified type name, for example X.Y or X(Of Z).Y. Represents a name in the global namespace. Represents a parenthesized list of generic type arguments. Syntax node class that represents a value of 'cref' attribute inside documentation comment trivia. Represents a parenthesized list of argument types for a signature inside CrefReferenceSyntax syntax. Represent a Yield statement. Represent a Await expression. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a single punctuation mark or operator in a VB program. Which one can be determined from the Kind property. Represents a sequence of characters appearing in source with no possible meaning in the Visual Basic language (e.g. the semicolon ';'). This token should only appear in SkippedTokenTrivia as an artifact of parsing error recovery. Represents an Xml NCName per Namespaces in XML 1.0 Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. Represents character data in Xml content also known as PCData or in an Xml attribute value. All text is here for now even text that does not need normalization such as comment, pi and cdata text. Represents an identifier token. This might include brackets around the name and a type character. Represents an integer literal token. Represents a floating literal token. Represents a Decimal literal token. Represents a Date literal token. Represents a string literal token. Represents a string literal token. Represents tokens that were skipped by the parser as part of error recovery, and thus are not part of any syntactic structure. Represents a documentation comment e.g. ''' <Summary> appearing in source. A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). For example, the M in <see cref="M" />. A param or type param symbol referenced by a name attribute (e.g. in a <param> or <typeparam> documentation comment tag). For example, the M in <param name="M" />. ExpressionSyntax node representing the object conditionally accessed. Represents true whitespace: spaces, tabs, newlines and the like. Represents line breaks that are syntactically insignificant. Represents colons that are syntactically insignificant. Represents a comment. Represents an explicit line continuation character at the end of a line, i.e., _ Represents a ''' prefix for an XML Documentation Comment. Represents text in a false preprocessor block Represents a #Const pre-processing constant declaration appearing in source. Represents the beginning of an #If pre-processing directive appearing in source. Represents the beginning of an #If pre-processing directive appearing in source. Represents an #Else pre-processing directive appearing in source. Represents an #End If pre-processing directive appearing in source. Represents the beginning of a #Region directive appearing in source. Represents an #End Region directive appearing in source. Represents the beginning of a #ExternalSource pre-processing directive appearing in source. Represents an #End ExternalSource pre-processing directive appearing in source. Represents an #ExternalChecksum pre-processing directive appearing in source. Represents #Enable Warning pre-processing directive appearing in source. Represents #Disable Warning pre-processing directive appearing in source. Represents an #r directive appearing in scripts. Represents an unrecognized pre-processing directive. This occurs when the parser encounters a hash '#' token at the beginning of a physical line but does recognize the text that follows as a valid Visual Basic pre-processing directive. Represents an alias identifier followed by an "=" token in an Imports clause. Represents an identifier name followed by a ":=" token in a named argument. Represents a "Do ... Loop" block. Represents a "Do ... Loop" block. Represents a "Do ... Loop" block. Represents a "Do ... Loop" block. Represents a "Do ... Loop" block. Represents a simple "Do" statement that begins a "Do ... Loop" block. Represents a "Do While" statement that begins a "Do ... Loop" block. Represents a "Do Until" statement that begins a "Do ... Loop" block. Represents a simple "Loop" statement that end a "Do ... Loop" block. Represents a "Loop While" statement that end a "Do ... Loop" block. Represents a "Loop Until" statement that end a "Do ... Loop" block. Represents a "While ..." clause of a "Do" or "Loop" statement. Represents an "Until ..." clause of a "Do" or "Loop" statement. Represents a single keyword in a VB program. Which keyword can be determined from the Kind property. Represents a NameOf expression. Represents an interpolated string expression. Represents literal text content in an interpolated string. Represents an embedded expression in an interpolated string expression e.g. '{expression[,alignment][:formatString]}'. Represents an alignment clause ', alignment' of an interpolated string embedded expression. Represents a format string clause ':formatString' of an interpolated string embedded expression. Represents a '$"' token in an interpolated string expression. Represents literal character data in interpolated string expression. Represents the end of interpolated string when parsing. Represents tuple literal expression. Represents tuple type. Represents an element of a tuple type supplying only the type Represents an element of a tuple type supplying element name and optionally a type. Trivia created when merge conflict markers (like "<<<<<<<") are detected in source code 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. Find enclosing WithStatement if it exists. Simplified version of ExtractAnonymousTypeMemberName implemented on inner tokens. Returns true if all arguments are of the specified kind and they are also missing. Returns true if all arguments are missing. Given a syntax node of query clause returns its leading keyword The base class for all nodes in the VB syntax tree. Used by structured trivia which has no parent node, so need to know syntax tree explicitly Returns a non-null SyntaxTree that owns this node. If this node was created with an explicit non-null SyntaxTree, returns that tree. Otherwise, if this node has a non-null parent, then returns the parent's SyntaxTree. Otherwise, returns a newly created SyntaxTree rooted at this node, preserving this node's reference identity. Returns the of the node. The language name this node is syntax of. The parent of this node. The parent node of this node, or Nothing if this node is the root. Deserialize a syntax node from a byte stream. Returns True if this node represents a directive. Same as accessing on . Slight performance improvement. Get the preceding trivia nodes of this node. If this node is a token, returns the preceding trivia associated with this node. If this is a non-terminal, returns the preceding trivia of the first token of this node. A list of the preceding trivia. If this node is a non-terminal, the parents of the trivia will be the first token of this non-terminal; NOT this node. Get the following trivia nodes of this node. If this node is a token, returns the following trivia associated with this node. If this is a non-terminal, returns the following trivia of the last token of this node. A list of the following trivia. If this node is a non-terminal, the parents of the trivia will be the first token of this non-terminal; NOT this node. Get all syntax errors associated with this node, or any child nodes, grand-child nodes, etc. The errors are not in order. Push any nodes that have errors in the given collection onto a stack Given a error info from this node, create the corresponding syntax error with the right span. Add an error to the given node, creating a new node that is the same except it has no parent, and has the given error attached to it. The error span is the entire span of this node. The error to attach to this node A new node, with no parent, that has this error added to it. Since nodes are immutable, the only way to create nodes with errors attached is to create a node without an error, then add an error with this method to create another node. Gets the location of this node. Gets a SyntaxReference for this syntax node. SyntaxReferences can be used to regain access to a syntax node without keeping the entire tree and source text in memory. Gets a list of all the diagnostics in the sub tree that has this node as its root. This method does not filter diagnostics based on compiler options like nowarn, warnaserror etc. Finds a token according to the following rules: 1) If position matches the End of the node's Span, then its last token is returned. 2) If node.FullSpan.Contains(position) then the token that contains given position is returned. 3) Otherwise an IndexOutOfRange is thrown The parsed representation of a Visual Basic source document. Map containing information about all conditional symbol definitions in the source file corresponding to a parsed syntax tree. Conditional symbols map, where each key-value pair indicates: Key: Conditional symbol name. Value: Stack of all active conditional symbol definitions, i.e. #Const directives, in the source file corresponding to a parsed syntax tree. All the defining #Const directives for a conditional symbol are pushed onto this stack in source code order. Each stack entry is a tuple {InternalSyntax.CConst, Integer} where: InternalSyntax.CConst: Constant value of the symbol. Integer: Source position of the defining #Const directive. Use by Expression Evaluator. Used to create new tree incrementally. Get a reference to the given node. A SyntaxTree is a tree of nodes that represents an entire file of VB code, and is parsed by the parser. Used to create new tree incrementally. Get a reference to the given node. The options used by the parser to produce the syntax tree. Returns True for MyTemplate automatically added by compiler. Produces a clone of a which will have current syntax tree as its parent. Caller must guarantee that if the same instance of makes multiple calls to this function, only one result is observable. Type of the syntax node. The original syntax node. A clone of the original syntax node that has current as its parent. Gets the root node of the syntax tree. Gets the root node of the syntax tree asynchronously. By default, the work associated with this method will be executed immediately on the current thread. Implementations that wish to schedule this work differently should override . Gets the root node of the syntax tree if it is already available. Gets the root of the syntax tree statically typed as . Ensure that is true for this tree prior to invoking this method. Throws this exception if is false. Creates a new syntax based off this tree using a new source text. If the new source text is a minor change from the current source text an incremental parse will occur reusing most of the current syntax tree internal data. Otherwise, a full parse will occur using the new source text. Applies a text change to this syntax tree, returning a new syntax tree with the changes applied to it. Creates a new syntax tree from a syntax node. An obsolete parameter. Diagnostic options should now be passed with Creates a new syntax tree from a syntax node with text that should correspond to the syntax node. This is used by the ExpressionEvaluator. Internal helper for class to create a new syntax tree rooted at the given root node. This method does not create a clone of the given root, but instead preserves its reference identity. NOTE: This method is only intended to be used from property. NOTE: Do not use this method elsewhere, instead use method for creating a syntax tree. An obsolete parameter. Diagnostic options should now be passed with Creates a syntax tree by parsing the source text. Gets a list of all the diagnostics in the sub tree that has the specified node as its root. This method does not filter diagnostics based on compiler options like /nowarn, /warnaserror etc. Gets a list of all the diagnostics associated with the token and any related trivia. This method does not filter diagnostics based on compiler options like /nowarn, /warnaserror etc. Gets a list of all the diagnostics associated with the trivia. This method does not filter diagnostics based on compiler options like /nowarn, /warnaserror etc. Gets a list of all the diagnostics in either the sub tree that has the specified node as its root or associated with the token and its related trivia. This method does not filter diagnostics based on compiler options like /nowarn, /warnaserror etc. Gets a list of all the diagnostics in the syntax tree. This method does not filter diagnostics based on compiler options like /nowarn, /warnaserror etc. Gets the location in terms of path, line and column for a given . Span within the tree. Cancellation token. that contains path, line and column information. The values are not affected by line mapping directives (#ExternalSource). Gets the location in terms of path, line and column after applying source line mapping directives (#ExternalSource). Span within the tree. Cancellation token. A valid that contains path, line and column information. If the location path is not mapped the resulting path is . Gets a location for the specified text . Determines if two trees are the same, disregarding trivia differences. The tree to compare against. If true then the trees are equivalent if the contained nodes and tokens declaring metadata visible symbolic information are equivalent, ignoring any differences of nodes inside method bodies or initializer expressions, otherwise all nodes and tokens must be equivalent. Produces a pessimistic list of spans that denote the regions of text in this tree that are changed from the text of the old tree. The old tree. Cannot be Nothing. The list is pessimistic because it may claim more or larger regions than actually changed. Gets a list of text changes that when applied to the old tree produce this tree. The old tree. Cannot be Nothing. The list of changes may be different than the original changes that produced this tree. Represents a that descends an entire tree visiting each SyntaxNode and its child s and s in depth-first order. Determine whether there is any substitution of type parameters that will make two types identical. Determine whether there is any substitution of type parameters that will make two types identical. The generic containing type. LHS RHS Substitutions performed so far (or null for none). Keys are type parameters, values are types (possibly type parameters). Will be updated with new substitutions by the callee. Irrelevant if false is returned. True if there exists a type map such that Map(LHS) == Map(RHS). Derived from C# Dev10's BSYMMGR::UnifyTypes. Two types will not unify if they have different custom modifiers. Add a type parameter -> type argument substitution to a TypeSubstitution object, returning a new TypeSubstitution object ByRef. Return true if the given type contains the specified type parameter. Utility functions to check if two implemented interfaces have variance ambiguity. What is "Variance Ambiguity"? Here's an example: Class ReflectionType Implements IEnumerable(Of Field) Implements IEnumerable(Of Method) Public Sub GetEnumeratorF() As IEnumerator(Of Field) Implements IEnumerable(Of Field).GetEnumerator ... Public Sub GetEnumeratorM() As IEnumerator(Of Method) Implements IEnumerable(Of Method).GetEnumerator ... End Class Dim x as new ReflectionType Dim y as IEnumerable(Of Member) = x Dim z = y.GetEnumerator() Note that, through variance, both IEnumerable(Of Field) and IEnumerable(Of Method) have widening conversions to IEnumerable(Of Member). So it's ambiguous whether the initialization of "z" would invoke GetEnumeratorF or GetEnumeratorM. This function avoids such ambiguity at the declaration level, i.e. it reports a warning on the two implements classes inside ReflectionType that they may lead to ambiguity. Determine if two interfaces that were constructed from the same original definition have variance ambiguity. We have something like left=ICocon(Of Mammal, int32[]), right=ICocon(Of Fish, int32[]) for some interface ICocon(Of Out T, In U). And we have to decide if left and right might lead to ambiguous member-lookup later on in execution. To do this: go through each type parameter T, U... * For "Out T", judge whether the arguments Mammal/Fish cause ambiguity or prevent it. * For "In T", judge whether the arguments int32[]/int32[] cause ambiguity or prevent it. "Causing/preventing ambiguity" is described further below. Given all that, ambiguity was prevented in any positions, then left/right are fine. Otherwise, if ambiguity wasn't caused in any positions, then left/right are fine. Otherwise, left/right have an ambiguity. Check two corresponding type arguments T1 and T2 and determine if the cause or prevent variable ambiguity. Identical types never cause or prevent ambiguity. If there could exist a **distinct** third type T3, such that T1 and T2 both convert via the variance conversion to T3, then ambiguity is caused. This boils down to: * Invariant parameters never cause ambiguity * Covariant parameters "Out T": ambiguity is caused when the two type arguments are non-object types not known to be values (T3=Object) * Contravariant parameters "In U": ambiguity is caused when both: - Neither T1 or T2 is a value type or a sealed (NotInheritable) reference type - If T1 and T2 are both class types, one derives from the other. (T3 is some type deriving or implementing both T1 and T2) Ambiguity is prevented when there T1 and T2 cannot unify to the same type, and there cannot be a (not necessarily distinct) third type T3 that both T1 and T2 convert to via the variance conversion. This boils down to: * Invariant parameters: Ambiguity is prevented when: - they are non-unifying * Covariant parameters "Out T": Ambiguity is prevented when both: - they are non-unifying - at least one is a value type * Contravariant parameters "In U": Ambiguity is prevented when: - they are non-unifying AND - at least one is known to be a value type OR - both are known to be class types and neither derives from the other. A class representing Visual Basic compilation Options. Initializes a new instance of the VisualBasicCompilationOptions type with various options. The compilation output kind. An optional parameter to specify the name of the assembly that this module will be a part of. An optional parameter to specify the class or module that contains the Sub Main procedure. An optional parameter to specify an alternate DefaultScriptClassName object to be used. An optional collection of GlobalImports . An optional parameter to specify the name of the default root namespace. An optional parameter to specify the default Option Strict behavior. An optional parameter to specify default Option Infer behavior. An optional parameter to specify the default Option Explicit behavior. An optional parameter to specify the default Option Compare Text behavior. An optional parameter to specify the embedded Visual Basic Core Runtime behavior. An optional parameter to specify enabling/disabling overflow checking. An optional parameter to specify enabling/disabling concurrent build. An optional parameter to specify a key container name for a key pair to give an assembly a strong name. An optional parameter to specify a file containing a key or key pair to give an assembly a strong name. An optional parameter to specify a public key used to give an assembly a strong name. An optional parameter to specify whether the assembly will be fully or partially signed. An optional parameter to specify which platform version of common language runtime (CLR) can run compilation. An optional parameter to specify the general warning level. An optional collection representing specific warnings that differ from general warning behavior. An optional parameter to enabled/disable optimizations. An optional parameter to specify the parse options. An optional parameter to specify the XML file resolver. An optional parameter to specify the source file resolver. An optional parameter to specify . An optional parameter to specify . An optional parameter to specify . An optional parameter to specify whether the assembly will be public signed. An optional parameter to specify whether or not suppressed diagnostics should be reported. An optional parameter to specify metadata import options. Gets the global imports collection. The global imports. Gets the default namespace for all source code in the project. Corresponds to the "RootNamespace" project option or the "/rootnamespace" command line option. The default namespace. Gets the Option Strict Setting. The Option Strict setting. Gets the Option Infer setting. The Option Infer setting. True if Option Infer On is in effect by default. False if Option Infer Off is on effect by default. Gets the Option Explicit setting. The Option Explicit setting. True if Option Explicit On is in effect by default. False if Option Explicit Off is on by default. Gets the Option Compare Text setting. The Option Compare Text Setting, True if Option Compare Text is in effect by default. False if Option Compare Binary is in effect by default. Gets the Embed Visual Basic Core Runtime setting. The EmbedVbCoreRuntime setting, True if VB core runtime should be embedded in the compilation. Equal to '/vbruntime*' Gets the embedded declaration suppression setting. The embedded declaration suppression setting. Gets the setting to ignore corlib types when duplicates are found. Gets the Parse Options setting. Compilation level parse options. Used when compiling synthetic embedded code such as My template The Parse Options Setting. Creates a new VisualBasicCompilationOptions instance with a different OutputKind specified. The Output Kind. A new instance of VisualBasicCompilationOptions, if the output kind is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance With a different ModuleName specified. The moduleName. A new instance of VisualBasicCompilationOptions, if the module name is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a Script Class Name specified. The name for the ScriptClassName. A new instance of VisualBasicCompilationOptions, if the script class name is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different Main Type name specified. The name for the MainType . A new instance of VisualBasicCompilationOptions, if the main type name is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different global imports specified. A collection of Global Imports . A new instance of VisualBasicCompilationOptions. Creates a new VisualBasicCompilationOptions instance with a different global imports specified. A collection of Global Imports . A new instance of VisualBasicCompilationOptions. Creates a new VisualBasicCompilationOptions instance with a different global imports specified. A collection of Global Imports . A new instance of VisualBasicCompilationOptions. Creates a new VisualBasicCompilationOptions instance with a different root namespace specified. The root namespace. A new instance of VisualBasicCompilationOptions, if the root namespace is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different option strict specified. The Option Strict setting. A new instance of VisualBasicCompilationOptions, if the option strict is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different option infer specified. The Option infer setting. A new instance of VisualBasicCompilationOptions, if the option infer is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different option explicit specified. The Option Explicit setting. A new instance of VisualBasicCompilationOptions, if the option explicit is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different Option Compare Text specified. The Option Compare Text setting. A new instance of VisualBasicCompilationOptions, if the option compare text is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different Embed VB Core Runtime specified. The Embed VB Core Runtime setting. A new instance of VisualBasicCompilationOptions, if the embed vb core runtime is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different Overflow checks specified. The overflow check setting. A new instance of VisualBasicCompilationOptions, if the overflow check is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different concurrent build specified. The concurrent build setting. A new instance of VisualBasicCompilationOptions, if the concurrent build is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different deterministic mode specified. The deterministic mode. A new instance of VisualBasicCompilationOptions, if the deterministic mode is different; otherwise the current instance. Creates a new VisualBasicCompilationOptions instance with a different extended custom debug information specified. The extended custom debug information setting. A new instance of VisualBasicCompilationOptions, if the extended custom debug information is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with different embedded declaration suppression setting specified. The embedded declaration suppression setting. A new instance of VisualBasicCompilationOptions, if the embedded declaration suppression setting is different; otherwise current instance. Only expected to be called from the expression compiler. Creates a new VisualBasicCompilationOptions instance with different ignoreCorLibraryDuplicatedTypes setting specified. The ignoreCorLibraryDuplicatedTypes setting. Only expected to be called from the expression compiler and interactive. Creates a new VisualBasicCompilationOptions instance with a different cryptography key container specified The name of the cryptography key container. A new instance of VisualBasicCompilationOptions, if the cryptography key container name is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different cryptography key file path specified. The cryptography key file path. A new instance of VisualBasicCompilationOptions, if the cryptography key path is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different public key. The cryptography key file path. A new instance of VisualBasicCompilationOptions, if the public key is different; otherwise current instance. Creates a new VisualBasicCompilationOptions instance with a different delay signing specified. The delay signing setting. A new instance of VisualBasicCompilationOptions, if the delay sign is different; otherwise current instance. Creates a new instance with a different platform specified. The platform setting. A new instance of VisualBasicCompilationOptions, if the platform is different; otherwise current instance. Creates a new instance with a different report warning specified. The Report Warning setting. A new instance of VisualBasicCompilationOptions, if the report warning is different; otherwise current instance. Creates a new instance with different specific warnings specified. Specific report warnings. A new instance of VisualBasicCompilationOptions, if the dictionary of report warning is different; otherwise current instance. Creates a new instance with different specific warnings specified. Specific report warnings. A new instance of VisualBasicCompilationOptions, if the dictionary of report warning is different; otherwise current instance. Creates a new instance with specified suppress diagnostics reporting option. Report suppressed diagnostics setting. A new instance of VisualBasicCompilationOptions, if the value is different from the current value; otherwise current instance. Creates a new instance with a specified . A new instance of , if the value is different; otherwise the current instance. Creates a new instance with a specified . A new instance of , if the value is different; otherwise the current instance. Creates a new instance with a different parse option specified. The parse option setting. A new instance of VisualBasicCompilationOptions, if the parse options is different; otherwise current instance. Determines whether the current object is equal to another object of the same type. A VisualBasicCompilationOptions to compare with this object A boolean value. True if the current object is equal to the other parameter; otherwise, False. Indicates whether the current object is equal to another object. A object to compare with this object A boolean value. True if the current object is equal to the other parameter; otherwise, False. Creates a hashcode for this instance. A hashcode representing this instance. Determines if the given raw kind value belongs to the Visual Basic enumeration. The raw value to test. when the raw value belongs to the Visual Basic syntax kind; otherwise, . Returns for from property. Returns for from property. Returns for from property. Returns for from property. Checks to see if SyntaxToken is a bracketed identifier. The source SyntaxToken. A boolean value, True if token represents a bracketed Identifier. Returns the Type character for a given syntax token. This returns type character for Identifiers or Integer, Floating Point or Decimal Literals. Examples: Dim a$ or Dim l1 = 1L The source SyntaxToken. A type character used for the specific Internal Syntax Token Types. The source token base for Integer literals. Base can be Decimal, Hex or Octal. The source SyntaxToken. An instance representing the integer literal base. Determines if the token represents a reserved or contextual keyword The source SyntaxToken. A boolean value True if token is a keyword. Determines if the token represents a reserved keyword The source SyntaxToken. A boolean value True if token is a reserved keyword. Determines if the token represents a contextual keyword A boolean value True if token is a contextual keyword. Determines if the token represents a preprocessor keyword The source SyntaxToken. A boolean value True if token is a pre processor keyword. Returns the Identifiertext for a specified SyntaxToken. Insert one or more tokens in the list at the specified index. A new list with the tokens inserted. Add one or more tokens to the end of the list. A new list with the tokens added. Replaces trivia on a specified SyntaxToken. The source SyntaxToken to change trivia on. The original Trivia. The updated Trivia. The updated SyntaxToken with replaced trivia. Replaces trivia on a specified SyntaxToken. Gets the DirectiveTriviaSyntax items for a specified SyntaxNode with optional filtering. The source SyntaxNode. The optional DirectiveTrivia Syntax filter predicate. A list of DirectiveTriviaSyntax items Gets the first DirectiveTriviaSyntax item for a specified SyntaxNode. The source SyntaxNode. The optional DirectiveTriviaSyntax filter predicate. The first DirectiveSyntaxTrivia item. Gets the last DirectiveTriviaSyntax item for a specified SyntaxNode. The source node The optional DirectiveTriviaSyntax filter predicate. The last DirectiveSyntaxTrivia item. Gets the root CompilationUnitSyntax for a specified SyntaxTree. The source SyntaxTree. A CompilationUnitSyntax. Gets the reporting state for a warning at a given source location based on warning directives. Determines if symbol is Shared. The source symbol. A boolean value, True if symbol is Shared; otherwise False. Gets all module members in a namespace. The source namespace symbol. An ImmutableArray of NamedTypeSymbol for all module members in namespace. Gets all module members in a specified namespace. The source namespace symbol. The name of the namespace. An ImmutableArray of NamedTypeSymbol for all module members in namespace. Gets the Semantic Model OptionStrict property. A source Semantic model object. The OptionStrict object for the semantic model instance OptionStrict property, otherwise Null if semantic model is Null. Gets the Semantic Model OptionInfer property. A source Semantic model object. A boolean values, for the semantic model instance OptionInfer property. otherwise Null if semantic model is Null. Gets the Semantic Model OptionExplicit property. A source Semantic model object. A boolean values, for the semantic model instance OptionExplicit property. otherwise Null if semantic model is Null. Gets the Semantic Model OptionCompareText property. A source Semantic model object. A boolean values, for the semantic model instance OptionCompareText property. otherwise Null if semantic model is Null. Gets the compilation RootNamespace property. A source Compilation object. A NamespaceSymbol instance, for the compilation instance RootNamespace property. otherwise Null if compilation instance is Null. Gets the compilation AliasImports property. A source Compilation object. An ImmutableArray of AliasSymbol, from the compilation instance AliasImports property; otherwise an empty ImmutableArray if compilation instance is Null. Gets the compilation MemberImports property. A source Compilation object. An ImmutableArray of NamespaceOrTypeSymbol, from the compilation instance MemberImports property; otherwise an empty ImmutableArray if compilation instance is Null. Determines what kind of conversion there is between the specified types. A source Compilation object. A source Typesymbol A destination Typesymbol A Conversion instance, representing the kind of conversion between the two type symbols; otherwise Null if compilation instance is Null. Gets the special type symbol in current compilation. A source Compilation object. The SpecialType to get. A NamedTypeSymbol for the specified type in compilation; Null if compilation is Null. Determines what kind of conversion there is between the expression syntax and a specified type. A source semantic model. A source expression syntax. A destination TypeSymbol. A Conversion instance, representing the kind of conversion between the expression and type symbol; otherwise Null if semantic model instance is Null. Determines what kind of conversion there is between the expression syntax and a specified type. A source semantic model. A position within the expression syntax. A source expression syntax. A destination TypeSymbol. A Conversion instance, representing the kind of conversion between the expression and type symbol; otherwise Null if semantic model instance is Null. Gets the corresponding symbol for a specified identifier. A source semantic model. A IdentifierSyntax object. A cancellation token. A symbol, for the specified identifier; otherwise Null if semantic model is Null. Gets the corresponding symbol for a specified tuple element. A source semantic model. A TupleElementSyntax object. A cancellation token. A symbol, for the specified element; otherwise Nothing. Gets the corresponding PropertySymbol for a specified FieldInitializerSyntax. A source semantic model. A FieldInitializerSyntax object. A cancellation token. A PropertySymbol. Null if semantic model is null. Gets the corresponding NamedTypeSymbol for a specified AnonymousObjectCreationExpressionSyntax. Gets the corresponding RangeVariableSymbol for a specified ExpressionRangeVariableSyntax. Gets the corresponding RangeVariableSymbol for a specified CollectionRangeVariableSyntax. Gets the corresponding RangeVariableSymbol for a specified AggregationRangeVariableSyntax. Gets the corresponding LabelSymbol for a specified LabelStatementSyntax. Gets the corresponding FieldSymbol for a specified EnumMemberDeclarationSyntax. Gets the corresponding NamedTypeSymbol for a specified TypeStatementSyntax. Gets the corresponding NamedTypeSymbol for a specified TypeBlockSyntax. Gets the corresponding NamedTypeSymbol for a specified EnumStatementSyntax. Gets the corresponding NamedTypeSymbol for a specified EnumBlockSyntax. Gets the corresponding NamespaceSymbol for a specified NamespaceStatementSyntax. Gets the corresponding NamespaceSymbol for a specified NamespaceBlockSyntax. Gets the corresponding ParameterSymbol for a specified ParameterSyntax. Gets the corresponding TypeParameterSymbol Symbol for a specified TypeParameterSyntax. Gets the corresponding NamedTypeSymbol for a specified DelegateStatementSyntax. Gets the corresponding MethodSymbol for a specified SubNewStatementSyntax. Gets the corresponding MethodSymbol for a specified MethodStatementSyntax. Gets the corresponding symbol for a specified DeclareStatementSyntax. Gets the corresponding MethodSymbol for a specified OperatorStatementSyntax. Gets the corresponding MethodSymbol for a specified MethodBlockBaseSyntax. Gets the corresponding PropertySymbol for a specified PropertyStatementSyntax. Gets the corresponding EventSymbol for a specified EventStatementSyntax. Gets the corresponding PropertySymbol for a specified PropertyBlockSyntax. Gets the corresponding EventSymbol for a specified EventBlockSyntax. Gets the corresponding LocalSymbol for a specified CatchStatementSyntax. Gets the corresponding MethodSymbol for a specified AccessorStatementSyntax. Gets the corresponding AliasSymbol for a specified AliasImportsClauseSyntax. Gets the corresponding ForEachStatementInfo containing semantic info for a specified ForEachStatementSyntax. Gets the corresponding ForEachStatementInfo containing semantic info for a specified ForBlockSyntax. Gets the corresponding AwaitExpressionInfo containing semantic info for a specified AwaitExpressionSyntax. If the given node is within a preprocessing directive, gets the preprocessing symbol info for it. Gets the corresponding SymbolInfo containing semantic info for a specified ExpressionSyntax. Returns what 'Add' method symbol(s), if any, corresponds to the given expression syntax within . Gets the corresponding SymbolInfo containing semantic info for a specified CrefReferenceSyntax. Gets the corresponding SymbolInfo containing semantic info for a specified AttributeSyntax. Gets the corresponding SymbolInfo containing semantic info for a specified AttributeSyntax. Gets the corresponding SymbolInfo containing semantic info for specified AttributeSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the corresponding TypeInfo containing semantic info for a specified ExpressionSyntax. Gets the underlying information from an that was created from Visual Basic code. The conversion expression to get original info from. The underlying . If the was not created from Visual Basic code. Gets the underlying information for InConversion of that was created from Visual Basic code. The argument to get original info from. The underlying of the InConversion. If the was not created from Visual Basic code. Gets the underlying information for OutConversion of that was created from Visual Basic code. The argument to get original info from. The underlying of the OutConversion. If the was not created from Visual Basic code. Gets the underlying information from this . This conversion is applied before the operator is applied to the result of this conversion and . This compound assignment must have been created from Visual Basic code. Gets the underlying information from this . This conversion is applied after the operator is applied, before the result is assigned to . This compound assignment must have been created from Visual Basic code. Gets the corresponding TypeInfo containing semantic info for a speculating an ExpressionSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the corresponding TypeInfo containing semantic info for a specified AttributeSyntax. Gets the corresponding ImmutableArray of Symbols for a specified ExpressionSyntax. Gets the corresponding ImmutableArray of Symbols for a speculating an ExpressionSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the corresponding ImmutableArray of Symbols for a specified AttributeSyntax. If "nameSyntax" resolves to an alias name, return the AliasSymbol corresponding to A. Otherwise return null. Binds the name in the context of the specified location and sees if it resolves to an alias name. If it does, return the AliasSymbol corresponding to it. Otherwise, return null. Returns information about methods associated with CollectionRangeVariableSyntax. Returns information about methods associated with AggregateClauseSyntax. Returns symbol information for a query clause. Syntax node type Symbol information returned Returns Distinct method associated with . Returns Where method associated with . Returns TakeWhile/SkipWhile method associated with . Returns Take/Skip method associated with . Returns GroupBy method associated with . Returns Join/GroupJoin method associated with . Returns Select method associated with , or if none is. Returns Select method associated with , which has only one and is the only query clause within . otherwise. The method call is injected by the compiler to make sure that query is translated to at least one method call. . Use instead. Returns Select method associated with within a , or otherwise if none is. Returns aggregate function associated with . Returns OrderBy/OrderByDescending/ThenBy/ThenByDescending method associated with . Analyze control-flow within a part of a method body. Analyze control-flow within a part of a method body. Analyze data-flow within an expression. Analyze data-flow within a set of contiguous statements. Analyze data-flow within a statement. Gets the SemanticModel for a MethodBlockBaseSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the SemanticModel for a RangeArgumentSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the SemanticModel for a ExecutableStatementSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the SemanticModel for a EqualsValueSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the SemanticModel for a AttributeSyntax at a given position, used in Semantic Info for items not appearing in source code. Gets the SemanticModel for a TypeSyntax at a given position, used in Semantic Info for items not appearing in source code. Emit the IL for the compilation into the specified stream. Compilation. Path of the file to which the compilation will be written. Path of the file to which the compilation's debug info will be written. Also embedded in the output file. Nothing to forego PDB generation. Path of the file to which the compilation's XML documentation will be written. Nothing to forego XML generation. Path of the file from which the compilation's Win32 resources will be read (in RES format). Null to indicate that there are none. List of the compilation's managed resources. Nothing to indicate that there are none. To cancel the emit process. Compilation or path is null. Path is empty or invalid. An error occurred while reading or writing a file. Represents Visual Basic parse options. Creates an instance of VisualBasicParseOptions. The parser language version. The documentation mode. The kind of source code. An enumerable sequence of KeyValuePair representing preprocessor symbols. Returns the specified language version, which is the value that was specified in the call to the constructor, or modified using the method, or provided on the command line. Returns the effective language version, which the compiler uses to select the language rules to apply to the program. The preprocessor symbols to parse with. May contain duplicate keys. The last one wins. Returns a collection of preprocessor symbol names. Returns a VisualBasicParseOptions instance for a specified language version. The parser language version. A new instance of VisualBasicParseOptions if different language version is different; otherwise current instance. Returns a VisualBasicParseOptions instance for a specified source code kind. The parser source code kind. A new instance of VisualBasicParseOptions if source code kind is different; otherwise current instance. Returns a VisualBasicParseOptions instance for a specified documentation mode. A new instance of VisualBasicParseOptions if documentation mode is different; otherwise current instance. Returns a VisualBasicParseOptions instance for a specified collection of KeyValuePairs representing pre-processor symbols. A collection representing pre-processor symbols A new instance of VisualBasicParseOptions. Returns a VisualBasicParseOptions instance for a specified collection of KeyValuePairs representing pre-processor symbols. An parameter array of KeyValuePair representing pre-processor symbols. A new instance of VisualBasicParseOptions. Returns a VisualBasicParseOptions instance for a specified collection of KeyValuePairs representing pre-processor symbols. An ImmutableArray of KeyValuePair representing pre-processor symbols. A new instance of VisualBasicParseOptions. Returns a ParseOptions instance for a specified Source Code Kind. The parser source code kind. A new instance of ParseOptions. Returns a ParseOptions instance for a specified Documentation Mode. The documentation mode. A new instance of ParseOptions. Enable some experimental language features for testing. Determines whether the current object is equal to another object of the same type. An VisualBasicParseOptions object to compare with this object A boolean value. True if the current object is equal to the other parameter; otherwise, False. Indicates whether the current object is equal to another object. An object to compare with this object A boolean value. True if the current object is equal to the other parameter; otherwise, False. Returns a hashcode for this instance. A hashcode representing this instance. trees({0}) trees({0}) must have root node with SyntaxKind.CompilationUnit. Cannot add compiler special tree Syntax tree already present Submission can have at most one syntax tree. Cannot remove compiler special tree SyntaxTree '{0}' not found to remove Tree must have a root node with SyntaxKind.CompilationUnit Compilation (Visual Basic): Node is not within syntax tree Can't reference compilation of type '{0}' from {1} compilation. position of type parameter too large Associated type does not have type parameters function return type Type argument cannot be Nothing Wrong number of type arguments file '{0}' could not be found unable to open response file '{0}' option '{0}' requires '{1}' option '{0}' can be followed only by '+' or '-' the value '{1}' is invalid for option '{0}' Compilation options '{0}' and '{1}' can't both be specified at the same time. The language name '{0}' is invalid. The language name for /preferreduilang is invalid The options /vbruntime* and /target:module cannot be combined. Command-line syntax error: Invalid Guid format '{0}' for option '{1}' Command-line syntax error: Missing Guid for option '{1}' Algorithm '{0}' is not supported unrecognized option '{0}'; ignored Unrecognized command-line option no input sources specified source file '{0}' specified multiple times Source file specified multiple times can't open '{0}' for writing: {1} code page '{0}' is invalid or not installed the file '{0}' is not a text file could not find library '{0}' Metadata references not supported. cannot specify both /win32icon and /win32resource ignoring /noconfig option because it was specified in a response file Ignoring /noconfig option because it was specified in a response file warning number '{0}' for the option '{1}' is either not configurable or not valid Warning number is either not configurable or not valid cannot infer an output file name from resource only input files; provide the '/out' option the /moduleassemblyname option may only be specified when building a target of type 'module' '{0}' is not a valid value for /moduleassemblyname Error embedding Win32 manifest: Option /win32manifest conflicts with /nowin32manifest. Option /win32manifest ignored. It can be specified only when the target is an assembly. Option /win32manifest ignored File name '{0}' is empty, contains invalid characters, has a drive specification without an absolute path, or is too long Statement is not valid in a namespace. Type '{0}' is not defined. 'Next' expected. Character constant must contain exactly one character. Reference required to assembly '{0}' containing the definition for event '{1}'. Add one to your project. Reference required to module '{0}' containing the definition for event '{1}'. Add one to your project. '#If' block must end with a matching '#End If'. '#ElseIf', '#Else', or '#End If' must be preceded by a matching '#If'. '#ElseIf' must be preceded by a matching '#If' or '#ElseIf'. Inheriting from '{0}' is not valid. Labels are not valid outside methods. Delegates cannot implement interface methods. Delegates cannot handle events. 'Is' operator does not accept operands of type '{0}'. Operands must be reference or nullable types. 'TypeOf ... Is' requires its left operand to have a reference type, but this operand has the value type '{0}'. Properties declared 'ReadOnly' cannot have a 'Set'. Properties declared 'WriteOnly' cannot have a 'Get'. Statement is not valid inside a method. Statement is not valid inside '{0}' block. Expression statement is only allowed at the end of an interactive submission. Property missing 'End Property'. 'End Sub' expected. 'End Function' expected. '#Else' must be preceded by a matching '#If' or '#ElseIf'. Derived classes cannot raise base class events. Try must have at least one 'Catch' or a 'Finally'. Events cannot have a return type. Bracketed identifier is missing closing ']'. Syntax error. Overflow. Character is not valid. Option Strict On prohibits operands of type Object for operator '{0}'. Loop control variable cannot be a property or a late-bound indexed array. First statement of a method body cannot be on the same line as the method declaration. Maximum number of errors has been exceeded. '{0}' is valid only within an instance method. '{0}' is not valid within a structure. Attribute constructor has a parameter of type '{0}', which is not an integral, floating-point or Enum type or one of Object, Char, String, Boolean, System.Type or 1-dimensional array of these types. Method cannot have both a ParamArray and Optional parameters. '{0}' statement requires an array. ParamArray parameter must be an array. ParamArray parameter must be a one-dimensional array. Array exceeds the limit of 32 dimensions. Arrays cannot be declared with 'New'. Too many arguments to '{0}'. Statements and labels are not valid between 'Select Case' and first 'Case'. Constant expression is required. Conversion from '{0}' to '{1}' cannot occur in a constant expression. 'Me' cannot be the target of an assignment. 'ReadOnly' variable cannot be the target of an assignment. 'Exit Sub' is not valid in a Function or Property. 'Exit Property' is not valid in a Function or Sub. 'Exit Function' is not valid in a Sub or Property. Expression is a value and therefore cannot be the target of an assignment. For loop control variable '{0}' already in use by an enclosing For loop. Next control variable does not match For loop control variable '{0}'. 'Case Else' can only appear inside a 'Select Case' statement. 'Case' can only appear inside a 'Select Case' statement. Constant cannot be the target of an assignment. Named arguments are not valid as array subscripts. 'If' must end with a matching 'End If'. 'While' must end with a matching 'End While'. 'Do' must end with a matching 'Loop'. 'For' must end with a matching 'Next'. 'With' must end with a matching 'End With'. 'Else' must be preceded by a matching 'If' or 'ElseIf'. 'End If' must be preceded by a matching 'If'. 'End Select' must be preceded by a matching 'Select Case'. 'Exit Do' can only appear inside a 'Do' statement. 'End While' must be preceded by a matching 'While'. 'Loop' must be preceded by a matching 'Do'. 'Next' must be preceded by a matching 'For'. 'End With' must be preceded by a matching 'With'. Label '{0}' is already defined in the current method. 'Select Case' must end with a matching 'End Select'. 'Exit For' can only appear inside a 'For' statement. 'Exit While' can only appear inside a 'While' statement. 'ReadOnly' property '{0}' cannot be the target of an assignment. 'Exit Select' can only appear inside a 'Select' statement. Branching out of a 'Finally' is not valid. '!' requires its left operand to have a type parameter, class or interface type, but this operand has the type '{0}'. Number of indices is less than the number of dimensions of the indexed array. Number of indices exceeds the number of dimensions of the indexed array. '{0}' is an Enum type and cannot be used as an expression. '{0}' is a type and cannot be used as an expression. '{0}' is a class type and cannot be used as an expression. '{0}' is a structure type and cannot be used as an expression. '{0}' is an interface type and cannot be used as an expression. '{0}' is a namespace and cannot be used as an expression. '{0}' is not a valid name and cannot be used as the root namespace name. '{0}' is an XML prefix and cannot be used as an expression. Use the GetXmlNamespace operator to create a namespace object. 'Inherits' can appear only once within a 'Class' statement and can only specify one class. Property without a 'ReadOnly' or 'WriteOnly' specifier must provide both a 'Get' and a 'Set'. 'WriteOnly' property must provide a 'Set'. 'ReadOnly' property must provide a 'Get'. Attribute '{0}' is not valid: Incorrect argument value. Label '{0}' is not defined. Error creating Win32 resources: {0} Cannot create temporary file: {0} First statement of this 'Sub New' must be a call to 'MyBase.New' or 'MyClass.New' because base class '{0}' of '{1}' does not have an accessible 'Sub New' that can be called with no arguments. {0} '{1}' must implement '{2}' for interface '{3}'. Leading '.' or '!' can only appear inside a 'With' statement. Only one of 'Public', 'Private', 'Protected', 'Friend', 'Protected Friend', or 'Private Protected' can be specified. Only one of 'NotOverridable', 'MustOverride', or 'Overridable' can be specified. Specifier is duplicated. {0} '{1}' and {2} '{3}' conflict in {4} '{5}'. Keyword does not name a type. Specifiers valid only at the beginning of a declaration. Type expected. Keyword is not valid as an identifier. 'End Enum' must be preceded by a matching 'Enum'. 'Enum' must end with a matching 'End Enum'. Declaration expected. End of parameter list expected. Cannot define parameters after a paramarray parameter. Specifiers and attributes are not valid on this statement. Expected one of 'Dim', 'Const', 'Public', 'Private', 'Protected', 'Friend', 'Shadows', 'ReadOnly' or 'Shared'. Comma expected. 'As' expected. ')' expected. '(' expected. 'New' is not valid in this context. Expression expected. 'Optional' expected. Identifier expected. Integer constant expected. End of statement expected. 'Option' must be followed by 'Compare', 'Explicit', 'Infer', or 'Strict'. 'Option Compare' must be followed by 'Text' or 'Binary'. 'Compare' expected. Option Strict On requires all variable declarations to have an 'As' clause. Option Strict On requires all Function, Property, and Operator declarations to have an 'As' clause. Option Strict On requires that all method parameters have an 'As' clause. Comma or ')' expected. 'Sub' or 'Function' expected. String constant expected. 'Lib' expected. Delegate class '{0}' has no Invoke method, so an expression of this type cannot be the target of a method call. 'Is' expected. 'Option {0}' statement can only appear once per file. 'Inherits' not valid in Modules. 'Implements' not valid in Modules. Implemented type must be an interface. '{0}' is not valid on a constant declaration. '{0}' is not valid on a WithEvents declaration. '{0}' is not valid on a member variable declaration. Parameter already declared with name '{0}'. 'Loop' cannot have a condition if matching 'Do' has one. Relational operator expected. 'Exit' must be followed by 'Sub', 'Function', 'Property', 'Do', 'For', 'While', 'Select', or 'Try'. Named argument expected. Named argument specifications must appear after all fixed arguments have been specified in a late bound invocation. Named argument expected. Please use language version {0} or greater to use non-trailing named arguments. '{0}' is not valid on a method declaration. '{0}' is not valid on an event declaration. '{0}' is not valid on a Declare. '{0}' is not valid on a local constant declaration. '{0}' is not valid on a local variable declaration. 'If', 'ElseIf', 'Else', 'Const', 'Region', 'ExternalSource', 'ExternalChecksum', 'Enable', 'Disable', 'End' or 'R' expected. '=' expected. Type '{0}' has no constructors. 'End Interface' must be preceded by a matching 'Interface'. 'Interface' must end with a matching 'End Interface'. '{0}' inherits from '{1}'. '{0}' is nested in '{1}'. Class '{0}' cannot inherit from itself: {1} Classes can inherit only from other classes. '{0}' is already declared as '{1}' in this {2}. '{0}' cannot override '{1}' because they have different access levels. '{0}' cannot override '{1}' because it is declared 'NotOverridable'. '{0}' has multiple definitions with identical signatures. '{0}' has multiple definitions with identical signatures with different tuple element names, including '{1}'. '{0}' is not valid on an interface method declaration. '{0}' is not a parameter of '{1}'. '{0}' is not valid on an interface property declaration. Parameter '{0}' of '{1}' already has a matching argument. '{0}' is not valid on an interface event declaration. Type character '{0}' does not match declared data type '{1}'. 'Sub' or 'Function' expected after 'Delegate'. Enum '{0}' must contain at least one member. Constructor call is valid only as the first statement in an instance constructor. 'Sub New' cannot be declared 'Overrides'. 'Sub New' cannot be declared 'Partial'. Failed to emit module '{0}': {1} Cannot update '{0}'; attribute '{1}' is missing. {0} '{1}' cannot be declared 'Overrides' because it does not override a {0} in a base class. '.' expected. Local variable '{0}' is already declared in the current block. Statement cannot appear within a method body. End of method assumed. Local variable cannot have the same name as the function containing it. '{0}' contains '{1}' (variable '{2}'). Structure '{0}' cannot contain an instance of itself: {1} Interface '{0}' cannot inherit from itself: {1} '{0}' calls '{1}'. Constructor '{0}' cannot call itself: {1} '{0}' cannot inherit from {2} '{1}' because '{1}' is declared 'NotInheritable'. '{0}' and '{1}' cannot overload each other because they differ only by optional parameters. '{0}' and '{1}' cannot overload each other because they differ only by return types. Type character '{0}' cannot be used in a declaration with an explicit type. Type character cannot be used in a 'Sub' declaration because a 'Sub' doesn't return a value. '{0}' and '{1}' cannot overload each other because they differ only by the default values of optional parameters. Array subscript expression missing. '{0}' cannot override '{1}' because they differ by the default values of optional parameters. '{0}' cannot override '{1}' because they differ by optional parameters. Cannot refer to '{0}' because it is a member of the value-typed field '{1}' of class '{2}' which has 'System.MarshalByRefObject' as a base class. Value of type '{0}' cannot be converted to '{1}'. 'Case' cannot follow a 'Case Else' in the same 'Select' statement. Value of type '{0}' cannot be converted to '{1}' because '{2}' is not derived from '{3}'. Value of type '{0}' cannot be converted to '{1}' because '{2}' is not a reference type. 'For' loop control variable cannot be of type '{0}' because the type does not support the required operators. '{0}' and '{1}' cannot overload each other because they differ only by parameters declared 'ByRef' or 'ByVal'. Interface can inherit only from another interface. 'Inherits' statements must precede all declarations in an interface. 'Default' can be applied to only one property name in a {0}. '{0}' and '{1}' cannot overload each other because only one is declared 'Default'. '{0}' cannot override '{1}' because they differ by 'ReadOnly' or 'WriteOnly'. 'Sub New' cannot be declared in an interface. 'Sub New' cannot be declared '{0}'. '{0}' and '{1}' cannot overload each other because they differ only by 'ReadOnly' or 'WriteOnly'. Class '{0}' cannot be indexed because it has no default property. '{0}' and '{1}' cannot overload each other because they differ only by parameters declared 'ParamArray'. Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class. '}' expected. Module '{0}' cannot be used as a type. 'New' cannot be used on an interface. 'Catch' cannot appear after 'Finally' within a 'Try' statement. 'Catch' cannot appear outside a 'Try' statement. 'Finally' can only appear once in a 'Try' statement. 'Finally' cannot appear outside a 'Try' statement. 'End Try' must be preceded by a matching 'Try'. 'Try' must end with a matching 'End Try'. '{0}' is not valid on a Delegate declaration. Class '{0}' must declare a 'Sub New' because its base class '{1}' does not have an accessible 'Sub New' that can be called with no arguments. '{0}' is not accessible in this context because it is '{1}'. '{0}.{1}' is not accessible in this context because it is '{2}'. 'Catch' cannot catch type '{0}' because it is not 'System.Exception' or a class that inherits from 'System.Exception'. 'Exit Try' can only appear inside a 'Try' statement. '{0}' is not valid on a Structure declaration. '{0}' is not valid on an Enum declaration. '{0}' is not valid on an Interface declaration. '{0}' cannot override '{1}' because they differ by a parameter that is marked as 'ByRef' versus 'ByVal'. 'MyBase' cannot be used with method '{0}' because it is declared 'MustOverride'. '{0}' cannot implement '{1}' because there is no matching {2} on interface '{3}'. '{0}' cannot implement {1} '{2}' on interface '{3}' because the tuple element names in '{4}' do not match those in '{5}'. 'WithEvents' variables must have an 'As' clause. 'WithEvents' variables can only be typed as classes, interfaces or type parameters with class constraints. Value of type '{0}' cannot be converted to '{1}' because the array types have different numbers of dimensions. 'ReDim' cannot change the number of dimensions of an array. 'Sub Main' was not found in '{0}'. Constants must be of an intrinsic or enumerated type, not a class, structure, type parameter, or array type. 'End Sub' must be preceded by a matching 'Sub'. 'End Function' must be preceded by a matching 'Function'. 'End Property' must be preceded by a matching 'Property'. Methods in a Module cannot be declared '{0}'. Events in a Module cannot be declared '{0}'. Members in a Structure cannot be declared '{0}'. '{0}' cannot override '{1}' because they differ by their return types. '{0}' cannot override '{1}' because they differ by their tuple element names. Member cannot override because it differs by its tuple element names. Constants must have a value. Constant expression not representable in type '{0}'. 'Get' is already declared. 'Set' is already declared. '{0}' is not declared. It may be inaccessible due to its protection level. Operator '{0}' is not defined for types '{1}' and '{2}'. Expression is not a method. Argument not specified for parameter '{0}' of '{1}'. '{0}' is not a member of '{1}'. 'End Class' must be preceded by a matching 'Class'. Classes cannot be declared '{0}'. 'Imports' statements must precede any declarations. '{1}' for the Imports '{0}' does not refer to a Namespace, Class, Structure, Enum or Module. Type declaration characters are not valid in this context. Reference to a non-shared member requires an object reference. 'MyClass' cannot be used outside of a class. Expression is not an array or a method, and cannot have an argument list. 'WithEvents' variables cannot be typed as arrays. Shared 'Sub New' cannot have any parameters. Shared 'Sub New' cannot be declared '{0}'. 'Class' statement must end with a matching 'End Class'. Operator '{0}' is not defined for type '{1}'. 'Default' cannot be combined with '{0}'. Expression does not produce a value. Constructor must be declared as a Sub, not as a Function. Exponent is not valid. 'Sub New' cannot handle events. Constant '{0}' cannot depend on its own value. 'Shared' cannot be combined with '{0}' on a method declaration. 'Shared' cannot be combined with '{0}' on a property declaration. Properties in a Module cannot be declared '{0}'. Methods or events that implement interface members cannot be declared 'Shared'. Handles clause requires a WithEvents variable defined in the containing type or one of its base types. '{0}' cannot inherit from {1} '{2}' because it expands the access of the base {1} to {3} '{4}'. Option Strict On disallows implicit conversions from '{0}' to '{1}'. Overload resolution failed because no accessible '{0}' accepts this number of arguments. Overload resolution failed because no '{0}' is accessible. Overload resolution failed because no accessible '{0}' can be called with these arguments:{1} Overload resolution failed because no accessible '{0}' can be called:{1} Overload resolution failed because no accessible '{0}' can be called without a narrowing conversion:{1} Argument matching parameter '{0}' narrows from '{1}' to '{2}'. Overload resolution failed because no accessible '{0}' is most specific for these arguments:{1} Not most specific. '{0}': {1} Property '{0}' is 'WriteOnly'. Property '{0}' is 'ReadOnly'. All parameters must be explicitly typed if any of them are explicitly typed. Parameter cannot have the same name as its defining function. Conversion from 'Date' to 'Double' requires calling the 'Date.ToOADate' method. Conversion from 'Double' to 'Date' requires calling the 'Date.FromOADate' method. Division by zero occurred while evaluating this expression. Method cannot contain both a 'Try' statement and an 'On Error' or 'Resume' statement. Property access must assign to the property or use its value. '{0}' cannot be indexed because it has no default property. Attribute '{0}' cannot be applied to an assembly. Attribute '{0}' cannot be applied to a module. '{0}' is ambiguous. Default member of '{0}' is not a property. '{0}' is ambiguous in the namespace '{1}'. '{0}' is ambiguous, imported from the namespaces or types '{1}'. '{0}' is ambiguous between declarations in Modules '{1}'. '{0}' is ambiguous between declarations in namespaces '{1}'. Array initializer has too few dimensions. Array initializer has too many dimensions. Array initializer is missing {0} elements. Array initializer has {0} too many elements. 'New' cannot be used on a class that is declared 'MustInherit'. Alias '{0}' is already declared. XML namespace prefix '{0}' is already declared. stdin argument '-' is specified, but input has not been redirected from the standard input stream. Option Strict On disallows late binding. 'AddressOf' operand must be the name of a method (without parentheses). '#End ExternalSource' must be preceded by a matching '#ExternalSource'. '#ExternalSource' statement must end with a matching '#End ExternalSource'. '#ExternalSource' directives cannot be nested. 'AddressOf' expression cannot be converted to '{0}' because '{0}' is not a delegate type. 'SyncLock' operand cannot be of type '{0}' because '{0}' is not a reference type. '{0}.{1}' cannot be implemented more than once. '{0}' cannot be inherited more than once. Named argument cannot match a ParamArray parameter. Omitted argument cannot match a ParamArray parameter. Argument cannot match a ParamArray parameter. Event '{0}' cannot be found. Variables in Modules cannot be declared '{0}'. Events of shared WithEvents variables cannot be handled by non-shared methods. Events of shared WithEvents variables cannot be handled by methods in a different type. '-' expected. Interface members must be methods, properties, events, or type definitions. Statement cannot appear within an interface body. Statement cannot appear within an interface body. End of interface assumed. 'NotInheritable' classes cannot have members declared '{0}'. Class '{0}' must either be declared 'MustInherit' or override the following inherited 'MustOverride' member(s): {1}. '{0}' is a MustOverride event in the base class '{1}'. Visual Basic does not support event overriding. You must either provide an implementation for the event in the base class, or make class '{2}' MustInherit. Array dimensions cannot have a negative size. 'MustOverride' method '{0}' cannot be called with 'MyClass'. 'End' statement cannot be used in class library projects. Variable '{0}' hides a variable in an enclosing block. 'Module' statements can occur only at file or namespace level. 'Namespace' statements can occur only at file or namespace level. Statement cannot appear within an Enum body. Statement cannot appear within an Enum body. End of Enum assumed. 'Option Strict' can be followed only by 'On' or 'Off'. 'End Structure' must be preceded by a matching 'Structure'. 'End Module' must be preceded by a matching 'Module'. 'End Namespace' must be preceded by a matching 'Namespace'. 'Structure' statement must end with a matching 'End Structure'. 'Module' statement must end with a matching 'End Module'. 'Namespace' statement must end with a matching 'End Namespace'. 'Option' statements must precede any declarations or 'Imports' statements. Structures cannot have 'Inherits' statements. Structures cannot declare a non-shared 'Sub New' with no parameters. 'End Get' must be preceded by a matching 'Get'. 'Get' statement must end with a matching 'End Get'. 'End Set' must be preceded by a matching 'Set'. 'Set' statement must end with a matching 'End Set'. Statement cannot appear within a property body. End of property assumed. 'ReadOnly' and 'WriteOnly' cannot be combined. '>' expected. Assembly or Module attribute statements must precede any declarations in a file. Array bounds cannot appear in type specifiers. Properties cannot be declared '{0}'. 'Option Explicit' can be followed only by 'On' or 'Off'. 'ByVal' and 'ByRef' cannot be combined. 'Optional' and 'ParamArray' cannot be combined. Property '{0}' is of an unsupported type. Attribute '{0}' cannot be applied to a method with optional parameters. 'Return' statement in a Sub or a Set cannot return a value. String constants must end with a double quote. '{0}' is an unsupported type. Enums must be declared as an integral type. {0} parameters cannot be declared 'ByRef'. Reference required to assembly '{0}' containing the type '{1}'. Add one to your project. Reference required to module '{0}' containing the type '{1}'. Add one to your project. 'Return' statement in a Function, Get, or Operator must return a value. Field '{0}' is of an unsupported type. '{0}' has a return type that is not supported or parameter types that are not supported. Property '{0}' with no parameters cannot be found. Property or field '{0}' does not have a valid attribute type. Attributes cannot be applied to local variables. Field or property '{0}' is not found. Attribute '{0}' cannot be applied to '{1}' because the attribute is not valid on this declaration type. Attribute '{0}' cannot be applied to '{1}' of '{2}' because the attribute is not valid on this declaration type. Class '{0}' cannot reference its nested type '{1}' in Inherits clause. Class '{0}' cannot reference itself in Inherits clause. Base type of '{0}' needs '{1}' to be resolved. Inherits clause of {0} '{1}' causes cyclic dependency: {2} Attribute '{0}' cannot be applied multiple times. Attribute '{0}' in '{1}' cannot be applied multiple times. 'Throw' operand must derive from 'System.Exception'. 'Throw' statement cannot omit operand outside a 'Catch' statement or inside a 'Finally' statement. ParamArray parameters must be declared 'ByVal'. '{0}' is obsolete: '{1}'. 'ReDim' statements require a parenthesized list of the new bounds of each dimension of the array. Explicit initialization is not permitted with multiple variables declared with a single type specifier. Explicit initialization is not permitted for arrays declared with explicit bounds. 'End SyncLock' must be preceded by a matching 'SyncLock'. 'SyncLock' statement must end with a matching 'End SyncLock'. '{0}' is not an event of '{1}'. 'AddHandler' or 'RemoveHandler' statement event operand must be a dot-qualified expression or a simple name. 'End' statement not valid. Array initializers are valid only for arrays, but the type of '{0}' is '{1}'. '#End Region' must be preceded by a matching '#Region'. '#Region' statement must end with a matching '#End Region'. 'Inherits' statement must precede all declarations in a class. '{0}' is ambiguous across the inherited interfaces '{1}' and '{2}'. Default property access is ambiguous between the inherited interface members '{0}' of interface '{1}' and '{2}' of interface '{3}'. Events in interfaces cannot be declared '{0}'. Statement cannot appear outside of a method body. Structure '{0}' cannot be indexed because it has no default property. {0} '{1}' must be declared 'Shadows' because another member with this name is declared 'Shadows'. '{0}' cannot override '{1}' because they differ by the types of optional parameters. End of expression expected. Methods declared in structures cannot have 'Handles' clauses. Methods declared 'Overrides' cannot be declared 'Overridable' because they are implicitly overridable. '{0}' is already declared as a parameter of this method. Variable '{0}' is already declared as a parameter of this or an enclosing lambda expression. Type in a Module cannot be declared '{0}'. No accessible 'Main' method with an appropriate signature was found in '{0}'. 'Sub Main' is declared more than once in '{0}': {1} Value '{0}' cannot be converted to '{1}'. 'On Error' statements are not valid within 'SyncLock' statements. Option Strict On disallows implicit conversions from '{0}' to '{1}'; the Visual Basic 6.0 collection type is not compatible with the .NET Framework collection type. 'GoTo {0}' is not valid because '{0}' is inside a 'Try', 'Catch' or 'Finally' statement that does not contain this statement. 'GoTo {0}' is not valid because '{0}' is inside a 'SyncLock' statement that does not contain this statement. 'GoTo {0}' is not valid because '{0}' is inside a 'With' statement that does not contain this statement. 'GoTo {0}' is not valid because '{0}' is inside a 'For' or 'For Each' statement that does not contain this statement. Attribute cannot be used because it does not have a Public constructor. Event '{0}' specified by the 'DefaultEvent' attribute is not a publicly accessible event for this class. 'NonSerialized' attribute will not have any effect on this member because its containing class is not exposed as 'Serializable'. 'Continue' must be followed by 'Do', 'For' or 'While'. 'Continue Do' can only appear inside a 'Do' statement. 'Continue For' can only appear inside a 'For' statement. 'Continue While' can only appear inside a 'While' statement. Parameter specifier is duplicated. 'Declare' statements in a Module cannot be declared '{0}'. 'Declare' statements in a structure cannot be declared '{0}'. 'TryCast' operand must be reference type, but '{0}' is a value type. 'TryCast' operands must be class-constrained type parameter, but '{0}' has no class constraint. No accessible '{0}' is most specific: {1} Non-shared members in a Structure cannot be declared 'New'. None of the accessible 'Main' methods with the appropriate signatures found in '{0}' can be the startup method since they are all either generic or nested in generic types. Error in project-level import '{0}' at '{1}' : {2} '{1}' for the Imports alias to '{0}' does not refer to a Namespace, Class, Structure, Interface, Enum or Module. Field '{0}.{1}' has an invalid constant value. Method arguments must be enclosed in parentheses. Labels that are numbers must be followed by colons. 'Type' statements are no longer supported; use 'Structure' statements instead. 'Variant' is no longer a supported type; use the 'Object' type instead. 'Let' and 'Set' assignment statements are no longer supported. Property Get/Let/Set are no longer supported; use the new Property declaration syntax. 'Wend' statements are no longer supported; use 'End While' statements instead. 'ReDim' statements can no longer be used to declare array variables. Optional parameters must specify a default value. 'GoSub' statements are no longer supported. 'On GoTo' and 'On GoSub' statements are no longer supported. 'EndIf' statements are no longer supported; use 'End If' instead. 'D' can no longer be used to indicate an exponent, use 'E' instead. 'As Any' is not supported in 'Declare' statements. 'Get' statements are no longer supported. File I/O functionality is available in the 'Microsoft.VisualBasic' namespace. '{0}' cannot override '{1}' because they differ by parameters declared 'ParamArray'. This inheritance causes circular dependencies between {0} '{1}' and its nested or base type '{2}'. {0} '{1}' cannot inherit from a type nested within it. '{0}' cannot expose type '{1}' outside the project through {2} '{3}'. '{0}' cannot inherit from {1} '{2}' because it expands the access of the base {1} outside the assembly. '{0}' accessor of '{1}' is obsolete: '{2}'. '{0}' accessor of '{1}' is obsolete. '{0}' cannot expose the underlying delegate type '{1}' of the event it is implementing to {2} '{3}' through {4} '{5}'. '{0}' cannot expose the underlying delegate type '{1}' of the event it is implementing outside the project through {2} '{3}'. Type '{0}' is not supported because it either directly or indirectly inherits from itself. Class '{0}' must declare a 'Sub New' because the '{1}' in its base class '{2}' is marked obsolete. Class '{0}' must declare a 'Sub New' because the '{1}' in its base class '{2}' is marked obsolete: '{3}'. First statement of this 'Sub New' must be an explicit call to 'MyBase.New' or 'MyClass.New' because the '{0}' in the base class '{1}' of '{2}' is marked obsolete. First statement of this 'Sub New' must be an explicit call to 'MyBase.New' or 'MyClass.New' because the '{0}' in the base class '{1}' of '{2}' is marked obsolete: '{3}'. '{0}' cannot inherit from {1} '{2}' because it expands the access of type '{3}' to {4} '{5}'. '{0}' cannot inherit from {1} '{2}' because it expands the access of type '{3}' outside the assembly. Specified access '{0}' for '{1}' does not match the access '{2}' specified on one of its other partial types. 'MustInherit' cannot be specified for partial type '{0}' because it cannot be combined with 'NotInheritable' specified for one of its other partial types. 'MustOverride' cannot be specified on this member because it is in a partial type that is declared 'NotInheritable' in another partial definition. Base class '{0}' specified for class '{1}' cannot be different from the base class '{2}' of one of its other partial types. Type parameter name '{0}' does not match the name '{1}' of the corresponding type parameter defined on one of the other partial types of '{2}'. Constraints for this type parameter do not match the constraints on the corresponding type parameter defined on one of the other partial types of '{0}'. Late bound overload resolution cannot be applied to '{0}' because the accessing instance is an interface type. Conversion from '{0}' to '{1}' cannot occur in a constant expression used as an argument to an attribute. Member '{0}' that matches this signature cannot be overridden because the class '{1}' contains multiple members with this same name and signature: {2} '{0}' Member '{0}.{1}' that matches this signature cannot be implemented because the interface '{2}' contains multiple members with this same name and signature: '{3}' '{4}' 'AddressOf' expression cannot be converted to '{0}' because type '{0}' is declared 'MustInherit' and cannot be created. Generic methods cannot be exposed to COM. Syntax error in cast operator; two arguments separated by comma are required. Array initializer cannot be specified for a non constant dimension; use the empty initializer '{}'. No accessible method '{0}' has a signature compatible with delegate '{1}':{2} Attribute 'StructLayout' cannot be applied to a generic type. Range variable '{0}' hides a variable in an enclosing block or a range variable previously defined in the query expression. 'Option Infer' can be followed only by 'On' or 'Off'. Type of '{0}' cannot be inferred from an expression containing '{0}'. '{0}' in class '{1}' cannot override '{2}' in class '{3}' because an intermediate class '{4}' overrides '{2}' in class '{3}' but is not accessible. Type of '{0}' cannot be inferred because the loop bounds and the step clause do not convert to the same type. Type of '{0}' is ambiguous because the loop bounds and the step clause do not convert to the same type. '=' expected (object initializer). Name of field or property being initialized in an object initializer must start with '.'. '{' expected. Type or 'With' expected. Multiple initializations of '{0}'. Fields and properties can be initialized only once in an object initializer expression. Member '{0}' cannot be initialized in an object initializer expression because it is not a field or property. Member '{0}' cannot be initialized in an object initializer expression because it is shared. Property '{0}' cannot be initialized in an object initializer expression because it requires arguments. Property '{0}' cannot be initialized in an object initializer expression because all accessible overloads require arguments. Object initializer syntax cannot be used to initialize an instance of 'System.Object'. Initializer expected. The line continuation character '_' must be preceded by at least one white space and it must be followed by a comment or the '_' must be the last character on the line. Please use language version {0} or greater to use comments after line continuation character. Unable to load module file '{0}': {1} Unable to load referenced library '{0}': {1} Method '{0}' cannot handle event '{1}' because they do not have a compatible signature. Conditional compilation constant '{1}' is not valid: {0} Interface '{0}' can be implemented only once by this type. Interface '{0}' can be implemented only once by this type, but already appears with different tuple element names, as '{1}'. Interface '{0}' can be implemented only once by this type, but already appears with different tuple element names, as '{1}' (via '{2}'). Interface '{0}' (via '{1}') can be implemented only once by this type, but already appears with different tuple element names, as '{2}'. Interface '{0}' (via '{1}') can be implemented only once by this type, but already appears with different tuple element names, as '{2}' (via '{3}'). Interface '{0}' can be inherited only once by this interface, but already appears with different tuple element names, as '{1}'. Interface '{0}' can be inherited only once by this interface, but already appears with different tuple element names, as '{1}' (via '{2}'). Interface '{0}' (via '{1}') can be inherited only once by this interface, but already appears with different tuple element names, as '{2}'. Interface '{0}' (via '{1}') can be inherited only once by this interface, but already appears with different tuple element names, as '{2}' (via '{3}'). Interface '{0}' is not implemented by this class. '{0}' exists in multiple base interfaces. Use the name of the interface that declares '{0}' in the 'Implements' clause instead of the name of the derived interface. 'Sub New' cannot implement interface members. Arrays declared as structure members cannot be declared with an initial size. Events declared with an 'As' clause must have a delegate type. Protected types can only be declared inside of a class. Properties with no required parameters cannot be declared 'Default'. Initializers on structure members are valid only for 'Shared' members and constants. Namespace or type '{0}' has already been imported. Modules cannot be declared '{0}'. 'Implements' statements must follow any 'Inherits' statement and precede all declarations in a class. {0} '{1}' implicitly defines '{2}', which conflicts with a member implicitly declared for {3} '{4}' in {5} '{6}'. {0} '{1}' implicitly defines '{2}', which conflicts with a member of the same name in {3} '{4}'. {0} '{1}' conflicts with a member implicitly declared for {2} '{3}' in {4} '{5}'. {0} '{1}' conflicts with a Visual Basic Runtime {2} '{3}'. First argument to a security attribute must be a valid SecurityAction. Security attribute '{0}' has an invalid SecurityAction value '{1}'. SecurityAction value '{0}' is invalid for security attributes applied to an assembly. SecurityAction value '{0}' is invalid for security attributes applied to a type or a method. SecurityAction value '{0}' is invalid for PrincipalPermission attribute. Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute. Error reading file '{0}' specified for the named argument '{1}' for PermissionSet attribute: '{2}'. 'Set' method cannot have more than one parameter. 'Set' parameter must have the same type as the containing property. 'Set' parameter cannot be declared '{0}'. Method in a structure cannot be declared 'Protected', 'Protected Friend', or 'Private Protected'. Delegate in an interface cannot be declared '{0}'. Enum in an interface cannot be declared '{0}'. Class in an interface cannot be declared '{0}'. Structure in an interface cannot be declared '{0}'. Interface in an interface cannot be declared '{0}'. '{0}' is obsolete. '{0}' is a module and cannot be referenced as an assembly. '{0}' is an assembly and cannot be referenced as a module. Operator '{0}' is not defined for types '{1}' and '{2}'. Use 'Is' operator to compare two reference types. '{0}' is not a local variable or parameter, and so cannot be used as a 'Catch' variable. Members in a Module cannot implement interface members. Events cannot be declared with a delegate type that has a return type. Date constant is not valid. '{0}' cannot override '{1}' because it is not declared 'Overridable'. Array modifiers cannot be specified on both a variable and its type. 'NotOverridable' cannot be specified for methods that do not override another method. Types declared 'Private' must be inside another type. Import of type '{0}' from assembly or module '{1}' failed. Predefined type '{0}' is not defined or imported. ParamArray parameters must have an array type. Implementing class '{0}' for interface '{1}' cannot be found. Type '{0}' cannot be used as an implementing class. Reference to object under construction is not valid when calling another constructor. Implicit reference to object under construction is not valid when calling another constructor. Member '{0}' cannot be found in class '{1}'. This condition is usually the result of a mismatched 'Microsoft.VisualBasic.dll'. Property accessors cannot be declared '{0}'. Access modifier '{0}' is not valid. The access modifier of 'Get' and 'Set' should be more restrictive than the property access level. Access modifier can only be applied to either 'Get' or 'Set', but not both. 'Set' accessor of property '{0}' is not accessible. 'Get' accessor of property '{0}' is not accessible. 'WriteOnly' properties cannot have an access modifier on 'Set'. 'ReadOnly' properties cannot have an access modifier on 'Get'. Property accessors cannot be declared '{0}' in a 'NotOverridable' property. Property accessors cannot be declared '{0}' in a 'Default' property. Property cannot be declared '{0}' because it contains a 'Private' accessor. Implementing class '{0}' for interface '{1}' is not accessible in this context because it is '{2}'. Arrays used as attribute arguments are required to explicitly specify values for all elements. 'Exit AddHandler', 'Exit RemoveHandler' and 'Exit RaiseEvent' are not valid. Use 'Return' to exit from event members. Statement cannot appear within an event body. End of event assumed. 'Custom Event' must end with a matching 'End Event'. 'AddHandler' declaration must end with a matching 'End AddHandler'. 'RemoveHandler' declaration must end with a matching 'End RemoveHandler'. 'RaiseEvent' declaration must end with a matching 'End RaiseEvent'. 'Custom' modifier is not valid on events declared in interfaces. 'Custom' modifier is not valid on events declared without explicit delegate types. 'End Event' must be preceded by a matching 'Custom Event'. 'End AddHandler' must be preceded by a matching 'AddHandler' declaration. 'End RemoveHandler' must be preceded by a matching 'RemoveHandler' declaration. 'End RaiseEvent' must be preceded by a matching 'RaiseEvent' declaration. 'AddHandler' is already declared. 'RemoveHandler' is already declared. 'RaiseEvent' is already declared. 'AddHandler' definition missing for event '{0}'. 'RemoveHandler' definition missing for event '{0}'. 'RaiseEvent' definition missing for event '{0}'. 'AddHandler' and 'RemoveHandler' methods must have exactly one parameter. 'AddHandler' and 'RemoveHandler' method parameters cannot be declared 'ByRef'. Specifiers are not valid on 'AddHandler', 'RemoveHandler' and 'RaiseEvent' methods. 'AddHandler' and 'RemoveHandler' method parameters must have the same delegate type as the containing event. 'RaiseEvent' method must have the same signature as the containing event's delegate type '{0}'. 'AddHandler', 'RemoveHandler' and 'RaiseEvent' method parameters cannot be declared '{0}'. '{0}' cannot refer to itself through its default instance; use 'Me' instead. 'Custom' modifier can only be used immediately before an 'Event' declaration. Option Strict Custom can only be used as an option to the command-line compiler (vbc.exe). '{0}' cannot be applied to the 'AddHandler', 'RemoveHandler', or 'RaiseEvent' definitions. If required, apply the attribute directly to the event. Method '{0}' does not have a signature compatible with delegate '{1}'. XML name expected. XML namespace prefix '{0}' is not defined. Duplicate XML attribute '{0}'. End tag </{0}{1}{2}> expected. Element is missing an end tag. XML namespace prefix '{0}' is reserved for use by XML and the namespace URI cannot be changed. Required attribute 'version' missing from XML declaration. XML declaration does not allow attribute '{0}{1}{2}'. Embedded expression cannot appear inside a quoted attribute value. Try removing quotes. XML attribute 'version' must be the first attribute in XML declaration. XML attribute '{0}' must appear before XML attribute '{1}'. Expected closing '%>' for embedded expression. Expected closing '?>' for XML processor instruction. Expected closing '-->' for XML comment. Expected closing ']]>' for XML CDATA section. Expected matching closing single quote for XML attribute value. Expected matching closing double quote for XML attribute value. Expected beginning '<' for an XML tag. Expected quoted XML attribute value or embedded expression. Expected '/' for XML end tag. XML axis properties do not support late binding. Character '{0}' ({1}) is not allowed at the beginning of an XML name. Character '{0}' ({1}) is not allowed in an XML name. Character sequence '--' is not allowed in an XML comment. An embedded expression cannot be used here. Missing required white space. XML processing instruction name '{0}' is not valid. XML DTDs are not supported. White space cannot appear here. Expected closing ';' for XML entity. Expected '%=' at start of an embedded expression. XML entity references are not supported. Attribute value is not valid; expecting '{0}'. Attribute value is not valid; expecting '{0}' or '{1}'. Prefix '{0}' cannot be bound to namespace name reserved for '{1}'. Namespace declaration with prefix cannot have an empty value inside an XML literal. ':' is not allowed. XML qualified names cannot be used in this context. Namespace declaration must start with 'xmlns'. Element names cannot use the 'xmlns' prefix. XML literals and XML axis properties are not available. Add references to System.Xml, System.Xml.Linq, and System.Core or other assemblies declaring System.Linq.Enumerable, System.Xml.Linq.XElement, System.Xml.Linq.XName, System.Xml.Linq.XAttribute and Sys ... Unable to open Win32 manifest file '{0}' : {1} Cannot convert '{0}' to '{1}'. You can use the 'Value' property to get the string value of the first element of '{2}'. Cannot convert IEnumerable(Of XElement) to String Value of type '{0}' cannot be converted to '{1}'. You can use the 'Value' property to get the string value of the first element of '{2}'. Operator '{0}' is not defined for types '{1}' and '{2}'. You can use the 'Value' property to get the string value of the first element of '{3}'. Full width characters are not valid as XML delimiters. The value '{0}' is not a valid subsystem version. The version must be 6.02 or greater for ARM or AppContainerExe, and 4.00 or greater otherwise. Invalid file section alignment '{0}' Invalid output name: {0} Invalid debug information format: {0} /platform:anycpu32bitpreferred can only be used with /t:exe, /t:winexe and /t:appcontainerexe. Expression has the type '{0}' which is a restricted type and cannot be used to access members inherited from 'Object' or 'ValueType'. Expression of type '{0}' cannot be converted to 'Object' or 'ValueType'. Type characters are not allowed in label identifiers. '{0}' cannot be made nullable, and cannot be used as the data type of an array element, field, anonymous type member, type argument, 'ByRef' parameter, or return statement. Type characters are not allowed on Imports aliases. Class '{0}' has no accessible 'Sub New' and cannot be inherited. Local variables within methods of structures cannot be declared 'Static'. Static local variable '{0}' is already declared. Imports alias '{0}' conflicts with '{1}' declared in the root namespace. '{0}' cannot shadow a method declared 'MustOverride'. Event '{0}' cannot implement event '{2}.{1}' because its delegate type does not match the delegate type of another event implemented by '{0}'. '{0}' and '{1}' cannot be combined. {0} '{1}' must be declared 'Overloads' because another '{1}' is declared 'Overloads' or 'Overrides'. '{0}' must be declared 'MustInherit' because it contains methods declared 'MustOverride'. 'Handles' in classes must specify a 'WithEvents' variable, 'MyBase', 'MyClass' or 'Me' qualified with a single identifier. '{0}', implicitly declared for {1} '{2}', cannot shadow a 'MustOverride' method in the base {3} '{4}'. '{0}' cannot override '{1}' because it is not accessible in this context. 'Handles' in modules must specify a 'WithEvents' variable qualified with a single identifier. 'IsNot' requires operands that have reference types, but this operand has the value type '{0}'. '{0}' conflicts with the reserved member by this name that is implicitly declared in all enums. '{0}' is already declared in this {1}. 'System.Void' can only be used in a GetType expression. Event '{0}' cannot implement event '{1}' on interface '{2}' because their delegate types '{3}' and '{4}' do not match. Type '{0}' in assembly '{1}' has been forwarded to assembly '{2}'. Either a reference to '{2}' is missing from your project or the type '{0}' is missing from assembly '{2}'. '{0}' in assembly '{1}' has been forwarded to itself and so is an unsupported type. Non-intrinsic type names are not allowed in conditional compilation expressions. Syntax error in conditional compilation expression. Arrays of type 'System.Void' are not allowed in this expression. '{0}' is ambiguous because multiple kinds of members with this name exist in {1} '{2}'. Expression of type '{0}' can never be of type '{1}'. Partial methods must be declared 'Private' instead of '{0}'. Partial methods must be declared 'Private'. Method '{0}' cannot be declared 'Partial' because only one method '{1}' can be marked 'Partial'. Method '{0}' cannot implement partial method '{1}' because '{2}' already implements it. Only one method can implement a partial method. Partial methods must have empty method bodies. '{0}' cannot be declared 'Partial' because partial methods must be Subs. Method '{0}' does not have the same generic constraints as the partial method '{1}'. Partial method '{0}' cannot use the 'Implements' keyword. 'AddressOf' cannot be applied to '{0}' because '{0}' is a partial method without an implementation. Method '{0}' must be declared 'Private' in order to implement partial method '{1}'. Parameter name '{0}' does not match the name of the corresponding parameter, '{1}', defined on the partial method declaration '{2}'. Name of type parameter '{0}' does not match '{1}', the corresponding type parameter defined on the partial method declaration '{2}'. 'Shared' attribute property '{0}' cannot be the target of an assignment. 'ReadOnly' attribute property '{0}' cannot be the target of an assignment. Resource name '{0}' cannot be used more than once. Each linked resource and module must have a unique filename. Filename '{0}' is specified more than once in this assembly. '{0}' cannot be used as an attribute because it is not a class. '{0}' cannot be used as an attribute because it does not inherit from 'System.Attribute'. '{0}' cannot be used as an attribute because it is declared 'MustInherit'. Unable to open resource file '{0}': {1} Attribute member '{0}' cannot be the target of an assignment because it is not declared 'Public'. 'System.STAThreadAttribute' and 'System.MTAThreadAttribute' cannot both be applied to the same method. Project '{0}' makes an indirect reference to assembly '{1}', which contains '{2}'. Add a file reference to '{3}' to your project. Type '{0}' cannot be used in an attribute because it is not declared 'Public'. Type '{0}' cannot be used in an attribute because its container '{1}' is not declared 'Public'. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a Sub, Function, or Operator with a non-empty body. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a Declare. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a Get or Set. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a method that is generic or contained in a generic type. 'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to a class that is generic or contained inside a generic type. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to instance method. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to interface methods. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to 'AddHandler', 'RemoveHandler' or 'RaiseEvent' method. Friend assembly reference '{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified. Friend assembly reference '{0}' is invalid. Strong-name signed assemblies must specify a public key in their InternalsVisibleTo declarations. Friend declaration '{0}' is invalid and cannot be resolved. Member '{0}' cannot override member '{1}' defined in another assembly/project because the access modifier 'Protected Friend' expands accessibility. Use 'Protected' instead. Local variable '{0}' cannot be referred to before it is declared. '{0}' is not valid within a Module. Statement cannot end a block outside of a line 'If' statement. 'Char' values cannot be converted to '{0}'. Use 'Microsoft.VisualBasic.AscW' to interpret a character as a Unicode value or 'Microsoft.VisualBasic.Val' to interpret it as a digit. '{0}' values cannot be converted to 'Char'. Use 'Microsoft.VisualBasic.ChrW' to interpret a numeric value as a Unicode character or first convert it to 'String' to produce a digit. Delegate '{0}' requires an 'AddressOf' expression or lambda expression as the only argument to its constructor. Method declaration statements must be the first statement on a logical line. '{0}' cannot be named as a parameter in an attribute specifier because it is not a field or property. Option Strict On disallows operands of type Object for operator '{0}'. Use the 'Is' operator to test for object identity. Bounds can be specified only for the top-level array when initializing an array of arrays. 'Assembly' or 'Module' expected. '{0}' has no parameters and its return type cannot be indexed. Comma, ')', or a valid expression continuation expected. 'Resume' or 'GoTo' expected. '=' expected. Parameter '{0}' in '{1}' already has a matching omitted argument. '{0}' is an event, and cannot be called directly. Use a 'RaiseEvent' statement to raise an event. Expression is of type '{0}', which is not a collection type. Default values cannot be supplied for parameters that are not declared 'Optional'. 'MyBase' must be followed by '.' and an identifier. 'MyClass' must be followed by '.' and an identifier. Option Strict On disallows narrowing from type '{1}' to type '{2}' in copying the value of 'ByRef' parameter '{0}' back to the matching argument. '#ElseIf' cannot follow '#Else' as part of a '#If' block. Attribute specifier is not a complete statement. Use a line continuation to apply the attribute to the following statement. Class '{0}' must declare a 'Sub New' because its base class '{1}' has more than one accessible 'Sub New' that can be called with no arguments. 'Next' statement names more variables than there are matching 'For' statements. First statement of this 'Sub New' must be a call to 'MyBase.New' or 'MyClass.New' because base class '{0}' of '{1}' has more than one accessible 'Sub New' that can be called with no arguments. Array declared as for loop control variable cannot be declared with an initial size. The '{0}' keyword is used to overload inherited members; do not use the '{0}' keyword when overloading 'Sub New'. Type character cannot be used in a type parameter declaration. Too few type arguments to '{0}'. Too many type arguments to '{0}'. Type argument '{0}' does not inherit from or implement the constraint type '{1}'. '{0}' has no type parameters and so cannot have type arguments. 'New' cannot be used on a type parameter that does not have a 'New' constraint. Type parameter '{0}' can only have one constraint that is a class. Type constraint '{0}' must be either a class, interface or type parameter. Type parameter already declared with name '{0}'. Type parameter '{0}' for '{1}' cannot be inferred. 'Is' operand of type '{0}' can be compared only to 'Nothing' because '{0}' is a type parameter with no class constraint. Copying the value of 'ByRef' parameter '{0}' back to the matching argument narrows from type '{1}' to type '{2}'. '{0}' has the same name as a type parameter. {0} '{1}' cannot inherit from a type parameter. Type parameter not allowed in 'Implements' clause. Array lower bounds can be only '0'. Type constraint cannot be a 'NotInheritable' class. '{0}' cannot be used as a type constraint. Type parameters cannot be specified on this declaration. Type arguments are not valid because attributes cannot be generic. Type parameters, generic types or types contained in generic types cannot be used as attributes. Local variables within generic methods cannot be declared 'Static'. {0} '{1}' implicitly defines a member '{2}' which has the same name as a type parameter. Constraint type '{0}' already specified for this type parameter. Cannot implement interface '{0}' because its implementation could conflict with the implementation of another implemented interface '{1}' for some type arguments. Modules cannot be generic. Classes that are generic or contained in a generic type cannot inherit from an attribute class. 'Declare' statements are not allowed in generic types or types contained in generic types. '{0}' cannot override '{1}' because they differ by type parameter constraints. '{0}' cannot implement '{1}.{2}' because they differ by type parameter constraints. Type parameters or types constructed with type parameters are not allowed in attribute arguments. Generic methods cannot use 'Handles' clause. 'New' constraint cannot be specified multiple times for the same type parameter. Type argument '{0}' is declared 'MustInherit' and does not satisfy the 'New' constraint for type parameter '{1}'. Type argument '{0}' must have a public parameterless instance constructor to satisfy the 'New' constraint for type parameter '{1}'. Type parameter '{0}' must have either a 'New' constraint or a 'Structure' constraint to satisfy the 'New' constraint for type parameter '{1}'. Arguments cannot be passed to a 'New' used on a type parameter. Generic type '{0}' cannot be imported more than once. Overload resolution failed because no accessible '{0}' accepts this number of type arguments. Type arguments unexpected. '{0}' is already declared as a type parameter of this method. Type parameter cannot have the same name as its defining function. Type or 'New' expected. 'Of' required when specifying type arguments for a generic type or method. '(' unexpected. Arrays of uninstantiated generic types are not allowed. 'For Each' on type '{0}' is ambiguous because the type implements multiple instantiations of 'System.Collections.Generic.IEnumerable(Of T)'. 'IsNot' operand of type '{0}' can be compared only to 'Nothing' because '{0}' is a type parameter with no class constraint. Type parameters cannot be used as qualifiers. Comma or ')' expected. 'As', comma or ')' expected. 'Class' constraint cannot be specified multiple times for the same type parameter. 'Structure' constraint cannot be specified multiple times for the same type parameter. 'New' constraint and 'Structure' constraint cannot be combined. 'Class' constraint and 'Structure' constraint cannot be combined. Type argument '{0}' does not satisfy the 'Structure' constraint for type parameter '{1}'. Type argument '{0}' must be a non-nullable value type, along with all fields at any level of nesting, in order to use it as type parameter '{1}'. Type argument '{0}' does not satisfy the 'Class' constraint for type parameter '{1}'. 'Class' constraint and a specific class type constraint cannot be combined. 'Structure' constraint and a specific class type constraint cannot be combined. Indirect constraint '{0}' obtained from the type parameter constraint '{1}' conflicts with the indirect constraint '{2}' obtained from the type parameter constraint '{3}'. Constraint '{0}' conflicts with the indirect constraint '{1}' obtained from the type parameter constraint '{2}'. Indirect constraint '{0}' obtained from the type parameter constraint '{1}' conflicts with the constraint '{2}'. '{0}' is constrained to '{1}'. Type parameter '{0}' cannot be constrained to itself: {1} Type parameter with a 'Structure' constraint cannot be used as a constraint. 'System.Nullable' does not satisfy the 'Structure' constraint for type parameter '{0}'. Only non-nullable 'Structure' types are allowed. Constraint '{0}' conflicts with the constraint '{1}' already specified for type parameter '{2}'. Cannot inherit interface '{0}' because it could be identical to interface '{1}' for some type arguments. Cannot inherit interface '{0}' because the interface '{1}' from which it inherits could be identical to interface '{2}' for some type arguments. Cannot inherit interface '{0}' because the interface '{1}' from which it inherits could be identical to interface '{2}' from which the interface '{3}' inherits for some type arguments. Cannot inherit interface '{0}' because it could be identical to interface '{1}' from which the interface '{2}' inherits for some type arguments. Cannot implement interface '{0}' because the interface '{1}' from which it inherits could be identical to implemented interface '{2}' for some type arguments. Cannot implement interface '{0}' because the interface '{1}' from which it inherits could be identical to interface '{2}' from which the implemented interface '{3}' inherits for some type arguments. Cannot implement interface '{0}' because it could be identical to interface '{1}' from which the implemented interface '{2}' inherits for some type arguments. Generic parameters used as optional parameter types must be class constrained. Methods of 'System.Nullable(Of T)' cannot be used as operands of the 'AddressOf' operator. 'Is' operand of type '{0}' can be compared only to 'Nothing' because '{0}' is a nullable type. 'IsNot' operand of type '{0}' can be compared only to 'Nothing' because '{0}' is a nullable type. '{0}' cannot be declared 'Shadows' outside of a class, structure, or interface. Property parameters cannot have the name 'Value'. The project currently contains references to more than one version of '{0}', a direct reference to version {2} and an indirect reference to version {1}. Change the direct reference to use version {1} (or higher) of {0}. Multiple assemblies with equivalent identity have been imported: '{0}' and '{1}'. Remove one of the duplicate references. Project already has a reference to assembly '{0}'. A second reference to '{1}' cannot be added. Illegal call expression or index expression. Conflict between the default property and the 'DefaultMemberAttribute' defined on '{0}'. '{0}' cannot be applied because the format of the GUID '{1}' is not correct. 'Microsoft.VisualBasic.ComClassAttribute' and '{0}' cannot both be applied to the same class. 'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to '{0}' because its container '{1}' is not declared 'Public'. 'System.Runtime.InteropServices.DispIdAttribute' cannot be applied to '{0}' because 'Microsoft.VisualBasic.ComClassAttribute' reserves zero for the default property. 'System.Runtime.InteropServices.DispIdAttribute' cannot be applied to '{0}' because 'Microsoft.VisualBasic.ComClassAttribute' reserves values less than zero. 'InterfaceId' and 'EventsId' parameters for 'Microsoft.VisualBasic.ComClassAttribute' on '{0}' cannot have the same value. 'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to a class that is declared 'MustInherit'. 'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to '{0}' because it is not declared 'Public'. Operator declaration must be one of: +, -, *, \, /, ^, &, Like, Mod, And, Or, Xor, Not, <<, >>, =, <>, <, <=, >, >=, CType, IsTrue, IsFalse. 'Widening' and 'Narrowing' cannot be combined. Operator is not overloadable. Operator declaration must be one of: +, -, *, \, /, ^, &, Like, Mod, And, Or, Xor, Not, <<, >>, =, <>, <, <=, >, >=, CType, IsTrue, IsFalse. 'Handles' is not valid on operator declarations. 'Implements' is not valid on operator declarations. 'End Operator' expected. 'End Operator' must be the first statement on a line. 'End Operator' must be preceded by a matching 'Operator'. 'Exit Operator' is not valid. Use 'Return' to exit an operator. '{0}' parameters cannot be declared 'ParamArray'. '{0}' parameters cannot be declared 'Optional'. Operators must be declared 'Public'. Operators must be declared 'Shared'. Operators cannot be declared '{0}'. Operator '{0}' must have one parameter. Operator '{0}' must have two parameters. Operator '{0}' must have either one or two parameters. Conversion operators must be declared either 'Widening' or 'Narrowing'. Operators cannot be declared in modules. Only conversion operators can be declared '{0}'. Parameter of this unary operator must be of the containing type '{0}'. At least one parameter of this binary operator must be of the containing type '{0}'. Either the parameter type or the return type of this conversion operator must be of the containing type '{0}'. Operator '{0}' must have a return type of Boolean. Conversion operators cannot convert from a type to the same type. Conversion operators cannot convert to an interface type. Conversion operators cannot convert from a type to its base type. Conversion operators cannot convert from a type to its derived type. Conversion operators cannot convert to Object. Conversion operators cannot convert from an interface type. Conversion operators cannot convert from a base type. Conversion operators cannot convert from a derived type. Conversion operators cannot convert from Object. Matching '{0}' operator is required for '{1}'. Return and parameter types of '{0}' must be '{1}' to be used in a '{2}' expression. Type '{0}' must define operator '{1}' to be used in a '{2}' expression. Cannot copy the value of 'ByRef' parameter '{0}' back to the matching argument because type '{1}' cannot be converted to type '{2}'. Type '{0}' must define operator '{1}' to be used in a 'For' statement. Return and parameter types of '{0}' must be '{1}' to be used in a 'For' statement. Parameter types of '{0}' must be '{1}' to be used in a 'For' statement. Operator '{0}' must have a second parameter of type 'Integer' or 'Integer?'. Nullable modifier cannot be specified on both a variable and its type. Type '{0}' must be a value type or a type argument constrained to 'Structure' in order to be used with 'Nullable' or nullable modifier '?'. Nullable modifier '?' and array modifiers '(' and ')' cannot be specified on both a variable and its type. Expressions used with an 'If' expression cannot contain type characters. 'If' operands cannot be named arguments. Cannot infer a common type for the second and third operands of the 'If' operator. One must have a widening conversion to the other. First operand in a binary 'If' expression must be a nullable value type, a reference type, or an unconstrained generic type. 'If' operator cannot be used in a 'Call' statement. Nullable modifier cannot be specified in variable declarations with 'As New'. Cannot infer a common type for the first and second operands of the binary 'If' operator. One must have a widening conversion to the other. Nullable types are not allowed in conditional compilation expressions. Nullable modifier cannot be used with a variable whose implicit type is 'Object'. Requested operation is not available because the runtime library function '{0}' is not defined. 'Global' must be followed by '.' and an identifier. 'Global' not allowed in this context; identifier expected. 'Global' not allowed in handles; local name expected. 'ElseIf' must be preceded by a matching 'If' or 'ElseIf'. Attribute constructor has a 'ByRef' parameter of type '{0}'; cannot use constructors with byref parameters to apply the attribute. 'End Using' must be preceded by a matching 'Using'. 'Using' must end with a matching 'End Using'. 'GoTo {0}' is not valid because '{0}' is inside a 'Using' statement that does not contain this statement. 'Using' operand of type '{0}' must implement 'System.IDisposable'. 'Using' resource variable must have an explicit initialization. 'Using' resource variable type can not be array type. 'On Error' statements are not valid within 'Using' statements. '{0}' has the same name as a member used for type '{1}' exposed in a 'My' group. Rename the type or its enclosing namespace. Implicit variable '{0}' is invalid because of '{1}'. Object initializers require a field name to initialize. 'From' expected. Nested function does not have the same signature as delegate '{0}'. Nested sub does not have a signature that is compatible with delegate '{0}'. 'ByRef' parameter '{0}' cannot be used in a query expression. Expression cannot be converted into an expression tree. Instance members and 'Me' cannot be used within query expressions in structures. Variable cannot be initialized with non-array type '{0}'. References to 'ByRef' parameters cannot be converted to an expression tree. Anonymous type member or property '{0}' is already declared. Cannot convert anonymous type to an expression tree because a property of the type is used to initialize another property. Anonymous type property '{0}' cannot be used in the definition of a lambda expression within the same initialization list. 'Extension' attribute can be applied only to 'Module', 'Sub', or 'Function' declarations. Extension methods can be defined only in modules. Extension methods must declare at least one parameter. The first parameter specifies which type to extend. 'Optional' cannot be applied to the first parameter of an extension method. The first parameter specifies which type to extend. 'ParamArray' cannot be applied to the first parameter of an extension method. The first parameter specifies which type to extend. Anonymous type member name can be inferred only from a simple or qualified name with no arguments. '{0}' is not a member of '{1}'; it does not exist in the current context. The custom-designed version of 'System.Runtime.CompilerServices.ExtensionAttribute' found by the compiler is not valid. Its attribute usage flags must be set to allow assemblies, classes, and methods. Anonymous type member property '{0}' cannot be used to infer the type of another member property because the type of '{0}' is not yet established. Type characters cannot be used in anonymous type declarations. Type characters cannot be used in tuple literals. 'New' cannot be used with tuple type. Use a tuple literal expression instead. Predefined type '{0}' must be a structure. Extension method '{0}' has type constraints that can never be satisfied. Extension method '{0}' defined in '{1}': {2} Method does not have a signature compatible with the delegate. Type arguments could not be inferred from the delegate. Too many arguments. Parameter '{0}' already has a matching omitted argument. Parameter '{0}' already has a matching argument. '{0}' is not a method parameter. Argument not specified for parameter '{0}'. Type parameter '{0}' cannot be inferred. Extension method '{0}' defined in '{1}'. Anonymous type must contain at least one member. Anonymous type member name must be preceded by a period. Identifier expected, preceded with a period. Too many arguments to extension method '{0}' defined in '{1}'. Parameter '{0}' in extension method '{1}' defined in '{2}' already has a matching omitted argument. Parameter '{0}' of extension method '{1}' defined in '{2}' already has a matching argument. '{0}' is not a parameter of extension method '{1}' defined in '{2}'. Argument not specified for parameter '{0}' of extension method '{1}' defined in '{2}'. Type parameter '{0}' for extension method '{1}' defined in '{2}' cannot be inferred. Too few type arguments to extension method '{0}' defined in '{1}'. Too many type arguments to extension method '{0}' defined in '{1}'. 'In' or '=' expected. Expression of type '{0}' is not queryable. Make sure you are not missing an assembly reference and/or namespace import for the LINQ provider. Definition of method '{0}' is not accessible in this context. Method cannot contain both a '{0}' statement and a definition of a variable that is used in a lambda or query expression. '{0}{1}' is not valid because '{2}' is inside a scope that defines a variable that is used in a lambda or query expression. Instance of restricted type '{0}' cannot be used in a query expression. Range variable name can be inferred only from a simple or qualified name with no arguments. Range variable '{0}' is already declared. Type characters cannot be used in range variable declarations. 'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor. Multi-dimensional array cannot be converted to an expression tree. Late binding operations cannot be converted to an expression tree. 'By' expected. Range variable name cannot match the name of a member of the 'Object' class. 'In' expected. Name '{0}' is either not declared or not in the current scope. Return type of nested function matching parameter '{0}' narrows from '{1}' to '{2}'. Anonymous type member name cannot be inferred from an XML identifier that is not a valid Visual Basic identifier. Range variable name cannot be inferred from an XML identifier that is not a valid Visual Basic identifier. 'Into' expected. Aggregate function name cannot be used with a type character. 'On' expected. 'Equals' expected. 'And' expected. 'Equals' cannot compare a value of type '{0}' with a value of type '{1}'. You must reference at least one range variable on both sides of the 'Equals' operator. Range variable(s) {0} must appear on one side of the 'Equals' operator, and range variable(s) {1} must appear on the other. Lambda expression cannot be converted to '{0}' because '{0}' is not a delegate type. Lambda expression cannot be converted to '{0}' because type '{0}' is declared 'MustInherit' and cannot be created. A nullable type cannot be inferred for variable '{0}'. Nullable type inference is not supported in this context. 'Join' expected. Nullable parameters must specify a type. Range variable '{0}' hides a variable in an enclosing block, a previously defined range variable, or an implicitly declared variable in a query expression. Attributes cannot be applied to parameters of lambda expressions. Lambda expressions are not valid in the first expression of a 'Select Case' statement. 'AddressOf' expressions are not valid in the first expression of a 'Select Case' statement. The '?' character cannot be used here. Instance members and 'Me' cannot be used within a lambda expression in structures. 'ByRef' parameter '{0}' cannot be used in a lambda expression. Instance of restricted type '{0}' cannot be used in a lambda expression. Lambda parameter '{0}' hides a variable in an enclosing block, a previously defined range variable, or an implicitly declared variable in a query expression. Option Strict On requires each lambda expression parameter to be declared with an 'As' clause if its type cannot be inferred. Array modifiers cannot be specified on lambda expression parameter name. They must be specified on its type. Data type(s) of the type parameter(s) cannot be inferred from these arguments. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) in method '{0}' cannot be inferred from these arguments. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) in extension method '{0}' defined in '{1}' cannot be inferred from these arguments. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) cannot be inferred from these arguments. Data type(s) of the type parameter(s) in method '{0}' cannot be inferred from these arguments. Data type(s) of the type parameter(s) in extension method '{0}' defined in '{1}' cannot be inferred from these arguments. Data type(s) of the type parameter(s) cannot be inferred from these arguments because more than one type is possible. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) in method '{0}' cannot be inferred from these arguments because more than one type is possible. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) in extension method '{0}' defined in '{1}' cannot be inferred from these arguments because more than one type is possible. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) cannot be inferred from these arguments because more than one type is possible. Data type(s) of the type parameter(s) in method '{0}' cannot be inferred from these arguments because more than one type is possible. Data type(s) of the type parameter(s) in extension method '{0}' defined in '{1}' cannot be inferred from these arguments because more than one type is possible. Data type(s) of the type parameter(s) cannot be inferred from these arguments because they do not convert to the same type. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) in method '{0}' cannot be inferred from these arguments because they do not convert to the same type. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) in extension method '{0}' defined in '{1}' cannot be inferred from these arguments because they do not convert to the same type. Specifying the data type(s) explicitly might correct this error. Data type(s) of the type parameter(s) cannot be inferred from these arguments because they do not convert to the same type. Data type(s) of the type parameter(s) in method '{0}' cannot be inferred from these arguments because they do not convert to the same type. Data type(s) of the type parameter(s) in extension method '{0}' defined in '{1}' cannot be inferred from these arguments because they do not convert to the same type. Option Strict On does not allow narrowing in implicit type conversions between method '{0}' and delegate '{1}'. '{0}' is not accessible in this context because the return type is not accessible. 'Group' or an identifier expected. 'Group' not allowed in this context; identifier expected. Option Strict On does not allow narrowing in implicit type conversions between extension method '{0}' defined in '{2}' and delegate '{1}'. Extension Method '{0}' defined in '{2}' does not have a signature compatible with delegate '{1}'. Argument matching parameter '{0}' narrows to '{1}'. {0} Auto-implemented Properties contained in Structures cannot have initializers unless they are marked 'Shared'. XML elements cannot be selected from type '{0}'. XML attributes cannot be selected from type '{0}'. XML descendant elements cannot be selected from type '{0}'. Extension method '{0}' defined in '{1}' is not generic (or has no free type parameters) and so cannot have type arguments. Late-bound extension methods are not supported. Cannot infer a data type for '{0}' because the array dimensions do not match. Type of the range variable cannot be inferred, and late binding is not allowed with Option Strict on. Use an 'As' clause to specify the type. Type '{0}' cannot be embedded because it has generic argument. Consider disabling the embedding of interop types. Type '{0}' cannot be used across assembly boundaries because it has a generic type argument that is an embedded interop type. '{0}' is obsolete: '{1}'. Type or member is obsolete {0} '{1}' shadows an overloadable member declared in the base {2} '{3}'. If you want to overload the base method, this method must be declared 'Overloads'. Member shadows an overloadable member declared in the base type {0} '{1}' conflicts with {2} '{1}' in the base {3} '{4}' and should be declared 'Shadows'. Member conflicts with member in the base type and should be declared 'Shadows' {0} '{1}' shadows an overridable method in the base {2} '{3}'. To override the base method, this method must be declared 'Overrides'. Member shadows an overridable method in the base type Default property '{0}' conflicts with the default property '{1}' in the base {2} '{3}'. '{0}' will be the default property. '{0}' should be declared 'Shadows'. Default property conflicts with the default property in the base type '{0}' is obsolete. Type or member is obsolete Possible problem detected while building assembly: {0} Possible problem detected while building assembly Possible problem detected while building assembly '{0}': {1} Possible problem detected while building assembly 'Microsoft.VisualBasic.ComClassAttribute' is specified for class '{0}' but '{0}' has no public members that can be exposed to COM; therefore, no COM interfaces are generated. 'Microsoft.VisualBasic.ComClassAttribute' is specified for class but class has no public members that can be exposed to COM {0} '{1}' implicitly declares '{2}', which conflicts with a member in the base {3} '{4}', and so the {0} should be declared 'Shadows'. Property or event implicitly declares type or member that conflicts with a member in the base type {0} '{1}' conflicts with a member implicitly declared for {2} '{3}' in the base {4} '{5}' and should be declared 'Shadows'. Member conflicts with a member implicitly declared for property or event in the base type {0} '{1}' implicitly declares '{2}', which conflicts with a member implicitly declared for {3} '{4}' in the base {5} '{6}'. {0} should be declared 'Shadows'. Property or event implicitly declares member, which conflicts with a member implicitly declared for property or event in the base type '{0}' accessor of '{1}' is obsolete: '{2}'. Property accessor is obsolete '{0}' accessor of '{1}' is obsolete. Property accessor is obsolete Type of member '{0}' is not CLS-compliant. Type of member is not CLS-compliant '{0}' is not CLS-compliant because it derives from '{1}', which is not CLS-compliant. Type is not CLS-compliant because it derives from base type that is not CLS-compliant Return type of function '{0}' is not CLS-compliant. Return type of function is not CLS-compliant Type of parameter '{0}' is not CLS-compliant. Type of parameter is not CLS-compliant '{0}' is not CLS-compliant because the interface '{1}' it inherits from is not CLS-compliant. Type is not CLS-compliant because the interface it inherits from is not CLS-compliant {0} '{1}' cannot be marked CLS-compliant because its containing type '{2}' is not CLS-compliant. Member cannot be marked CLS-compliant because its containing type is not CLS-compliant Name '{0}' is not CLS-compliant. Name is not CLS-compliant Underlying type '{0}' of Enum is not CLS-compliant. Underlying type of Enum is not CLS-compliant Non CLS-compliant '{0}' is not allowed in a CLS-compliant interface. Non CLS-compliant member is not allowed in a CLS-compliant interface Non CLS-compliant 'MustOverride' member is not allowed in CLS-compliant type '{0}'. Non CLS-compliant 'MustOverride' member is not allowed in CLS-compliant type '{0}' is not CLS-compliant because it overloads '{1}' which differs from it only by array of array parameter types or by the rank of the array parameter types. Method is not CLS-compliant because it overloads method which differs from it only by array of array parameter types or by the rank of the array parameter types Root namespace '{0}' is not CLS-compliant. Root namespace is not CLS-compliant Name '{0}' in the root namespace '{1}' is not CLS-compliant. Part of the root namespace is not CLS-compliant Generic parameter constraint type '{0}' is not CLS-compliant. Generic parameter constraint type is not CLS-compliant Type '{0}' is not CLS-compliant. Type is not CLS-compliant Type of optional value for optional parameter '{0}' is not CLS-compliant. Type of optional value for optional parameter is not CLS-compliant System.CLSCompliantAttribute cannot be applied to property 'Get' or 'Set'. System.CLSCompliantAttribute cannot be applied to property 'Get' or 'Set' {0} '{1}' and partial {2} '{3}' conflict in {4} '{5}', but are being merged because one of them is declared partial. Type and partial type conflict, but are being merged because one of them is declared partial Type parameter '{0}' has the same name as a type parameter of an enclosing type. Enclosing type's type parameter will be shadowed. Type parameter has the same name as a type parameter of an enclosing type Could not find standard library '{0}'. Could not find standard library Delegate type '{0}' of event '{1}' is not CLS-compliant. Delegate type of event is not CLS-compliant System.Diagnostics.DebuggerHiddenAttribute does not affect 'Get' or 'Set' when applied to the Property definition. Apply the attribute directly to the 'Get' and 'Set' procedures as appropriate. System.Diagnostics.DebuggerHiddenAttribute does not affect 'Get' or 'Set' when applied to the Property definition Range specified for 'Case' statement is not valid. Make sure that the lower bound is less than or equal to the upper bound. Range specified for 'Case' statement is not valid '{0}' method for event '{1}' cannot be marked CLS compliant because its containing type '{2}' is not CLS compliant. AddHandler or RemoveHandler method for event cannot be marked CLS compliant because its containing type is not CLS compliant '{0}' in designer-generated type '{1}' should call InitializeComponent method. Constructor in designer-generated type should call InitializeComponent method Casing of namespace name '{0}' does not match casing of namespace name '{1}' in '{2}'. Casing of namespace name does not match Namespace or type specified in the Imports '{0}' doesn't contain any public member or cannot be found. Make sure the namespace or the type is defined and contains at least one public member. Make sure the imported element name doesn't use any aliases. Namespace or type specified in Imports statement doesn't contain any public member or cannot be found Namespace or type specified in the project-level Imports '{0}' doesn't contain any public member or cannot be found. Make sure the namespace or the type is defined and contains at least one public member. Make sure the imported element name doesn't use any ... Namespace or type imported at project level doesn't contain any public member or cannot be found A reference was created to embedded interop assembly '{0}' because of an indirect reference to that assembly from assembly '{1}'. Consider changing the 'Embed Interop Types' property on either assembly. A reference was created to embedded interop assembly because of an indirect reference to that assembly Class '{0}' should declare a 'Sub New' because the '{1}' in its base class '{2}' is marked obsolete. Class should declare a 'Sub New' because the constructor in its base class is marked obsolete Class '{0}' should declare a 'Sub New' because the '{1}' in its base class '{2}' is marked obsolete: '{3}'. Class should declare a 'Sub New' because the constructor in its base class is marked obsolete First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the '{0}' in the base class '{1}' of '{2}' is marked obsolete. First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the constructor in the base class is marked obsolete First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the '{0}' in the base class '{1}' of '{2}' is marked obsolete: '{3}' First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the constructor in the base class is marked obsolete Operator without an 'As' clause; type of Object assumed. Operator without an 'As' clause Type arguments inferred for method '{0}' result in the following warnings :{1} Type arguments inferred for method result in warnings Attribute 'Conditional' is only valid on 'Sub' declarations. Attribute 'Conditional' is only valid on 'Sub' declarations Use command-line option '{0}' or appropriate project settings instead of '{1}'. Use command-line option /keyfile, /keycontainer, or /delaysign instead of AssemblyKeyFileAttribute, AssemblyKeyNameAttribute, or AssemblyDelaySignAttribute Statement recursively calls the containing '{0}' for event '{1}'. Statement recursively calls the event's containing AddHandler Implicit conversion from '{1}' to '{2}' in copying the value of 'ByRef' parameter '{0}' back to the matching argument. Implicit conversion in copying the value of 'ByRef' parameter back to the matching argument {0} '{1}' conflicts with other members of the same name across the inheritance hierarchy and so should be declared 'Shadows'. Method conflicts with other members of the same name across the inheritance hierarchy and so should be declared 'Shadows' Expression recursively calls the containing Operator '{0}'. Expression recursively calls the containing Operator Implicit conversion from '{0}' to '{1}'. Implicit conversion Local variable '{0}' is read-only and its type is a structure. Invoking its members or passing it ByRef does not change its content and might lead to unexpected results. Consider declaring this variable outside of the 'Using' block. Local variable declared by Using statement is read-only and its type is a structure Local variable '{0}' is read-only. When its type is a structure, invoking its members or passing it ByRef does not change its content and might lead to unexpected results. Consider declaring this variable outside of the 'Using' block. Local variable declared by Using statement is read-only and its type may be a structure {0} Implicit conversion Late bound resolution; runtime errors could occur. Late bound resolution Operands of type Object used for operator '{0}'; use the 'Is' operator to test object identity. Operands of type Object used for operator Operands of type Object used for operator '{0}'; runtime errors could occur. Operands of type Object used for operator {0} Variable declaration without an 'As' clause {0} Function without an 'As' clause {0} Property without an 'As' clause Variable declaration without an 'As' clause; type of Object assumed. Variable declaration without an 'As' clause Function without an 'As' clause; return type of Object assumed. Function without an 'As' clause Property without an 'As' clause; type of Object assumed. Property without an 'As' clause Unused local variable: '{0}'. Unused local variable Access of shared member, constant member, enum member or nested type through an instance; qualifying expression will not be evaluated. Access of shared member, constant member, enum member or nested type through an instance Expression recursively calls the containing property '{0}'. Expression recursively calls the containing property 'Catch' block never reached, because '{0}' inherits from '{1}'. 'Catch' block never reached; exception type's base type handled above in the same Try statement Variable '{0}' is passed by reference before it has been assigned a value. A null reference exception could result at runtime. Variable is passed by reference before it has been assigned a value 'Catch' block never reached; '{0}' handled above in the same Try statement. 'Catch' block never reached; exception type handled above in the same Try statement Operands of type Object used for operator '{0}'; use the 'IsNot' operator to test object identity. Operands of type Object used for operator <> Bad checksum value, non hex digits or odd number of hex digits. Bad checksum value, non hex digits or odd number of hex digits File name already declared with a different GUID and checksum value. File name already declared with a different GUID and checksum value Bad GUID format. Bad GUID format Operands of type Object used in expressions for 'Select', 'Case' statements; runtime errors could occur. Operands of type Object used in expressions for 'Select', 'Case' statements This expression will always evaluate to Nothing (due to null propagation from the equals operator). To check if the value is null consider using 'Is Nothing'. This expression will always evaluate to Nothing This expression will always evaluate to Nothing (due to null propagation from the equals operator). To check if the value is not null consider using 'IsNot Nothing'. This expression will always evaluate to Nothing Unused local constant: '{0}'. Unused local constant 'Microsoft.VisualBasic.ComClassAttribute' on class '{0}' implicitly declares {1} '{2}', which conflicts with a member of the same name in {3} '{4}'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the b ... 'Microsoft.VisualBasic.ComClassAttribute' on class implicitly declares member, which conflicts with a member of the same name '{0}' cannot be exposed to COM as a property 'Let'. You will not be able to assign non-object values (such as numbers or strings) to this property from Visual Basic 6.0 using a 'Let' statement. Property cannot be exposed to COM as a property 'Let' Variable '{0}' is used before it has been assigned a value. A null reference exception could result at runtime. Variable is used before it has been assigned a value Function '{0}' doesn't return a value on all code paths. A null reference exception could occur at run time when the result is used. Function doesn't return a value on all code paths Operator '{0}' doesn't return a value on all code paths. A null reference exception could occur at run time when the result is used. Operator doesn't return a value on all code paths Property '{0}' doesn't return a value on all code paths. A null reference exception could occur at run time when the result is used. Property doesn't return a value on all code paths Variable '{0}' is passed by reference before it has been assigned a value. A null reference exception could result at runtime. Make sure the structure or all the reference members are initialized before use Variable is passed by reference before it has been assigned a value Variable '{0}' is used before it has been assigned a value. A null reference exception could result at runtime. Make sure the structure or all the reference members are initialized before use Variable is used before it has been assigned a value Static variable declared without an 'As' clause; type of Object assumed. Static variable declared without an 'As' clause Assembly reference '{0}' is invalid and cannot be resolved. Assembly reference is invalid and cannot be resolved XML comment block must immediately precede the language element to which it applies. XML comment will be ignored. XML comment block must immediately precede the language element to which it applies Only one XML comment block is allowed per language element. Only one XML comment block is allowed per language element XML comment must be the first statement on a line. XML comment will be ignored. XML comment must be the first statement on a line XML comment cannot appear within a method or a property. XML comment will be ignored. XML comment cannot appear within a method or a property XML documentation parse error: {0} XML comment will be ignored. XML documentation parse error XML comment tag '{0}' appears with identical attributes more than once in the same XML comment block. XML comment tag appears with identical attributes more than once in the same XML comment block XML comment tag '{0}' is not permitted on a '{1}' language element. XML comment tag is not permitted on language element XML comment parameter '{0}' does not match a parameter on the corresponding '{1}' statement. XML comment parameter does not match a parameter on the corresponding declaration statement XML comment parameter must have a 'name' attribute. XML comment parameter must have a 'name' attribute XML comment has a tag with a 'cref' attribute '{0}' that could not be resolved. XML comment has a tag with a 'cref' attribute that could not be resolved XML comment tag 'include' must have a '{0}' attribute. XML comment will be ignored. XML comment tag 'include' must have 'file' and 'path' attributes Unable to create XML documentation file '{0}': {1} Unable to create XML documentation file XML documentation comments must precede member or type declarations. XML documentation comments must precede member or type declarations XML comment tag 'returns' is not permitted on a 'WriteOnly' Property. XML comment tag 'returns' is not permitted on a 'WriteOnly' Property XML comment cannot be applied more than once on a partial {0}. XML comments for this {0} will be ignored. XML comment cannot be applied more than once on a partial type XML comment tag 'returns' is not permitted on a 'declare sub' language element. XML comment tag 'returns' is not permitted on a 'declare sub' language element XML documentation parse error: Start tag '{0}' doesn't have a matching end tag. XML comment will be ignored. XML documentation parse error: Start tag doesn't have a matching end tag XML comment type parameter '{0}' does not match a type parameter on the corresponding '{1}' statement. XML comment type parameter does not match a type parameter on the corresponding declaration statement XML comment type parameter must have a 'name' attribute. XML comment type parameter must have a 'name' attribute XML comment exception must have a 'cref' attribute. XML comment exception must have a 'cref' attribute Unable to include XML fragment '{0}' of file '{1}'. Unable to include XML fragment Unable to include XML fragment '{1}' of file '{0}'. {2} Unable to include XML fragment Runtime errors might occur when converting '{0}' to '{1}'. Runtime errors might occur when converting to or from interface type Using the iteration variable in a lambda expression may have unexpected results. Instead, create a local variable within the loop and assign it the value of the iteration variable. Using the iteration variable in a lambda expression may have unexpected results Lambda expression will not be removed from this event handler. Assign the lambda expression to a variable and use the variable to add and remove the event. Lambda expression will not be removed from this event handler Using the iteration variable in a query expression may have unexpected results. Instead, create a local variable within the loop and assign it the value of the iteration variable. Using the iteration variable in a query expression may have unexpected results The 'AddressOf' expression has no effect in this context because the method argument to 'AddressOf' requires a relaxed conversion to the delegate type of the event. Assign the 'AddressOf' expression to a variable, and use the variable to add or remove the ... The 'AddressOf' expression has no effect in this context because the method argument to 'AddressOf' requires a relaxed conversion to the delegate type of the event Range variable is assumed to be of type Object because its type cannot be inferred. Use an 'As' clause to specify a different type. Range variable is assumed to be of type Object because its type cannot be inferred Multiline lambda expression is missing 'End Function'. Multiline lambda expression is missing 'End Sub'. Attributes cannot be applied to return types of lambda expressions. Statement is not valid inside a single-line statement lambda. This single-line statement lambda must be enclosed in parentheses. For example: (Sub() <statement>)!key This single-line statement lambda must be enclosed in parentheses. For example: (Sub() <statement>).Invoke() This single-line statement lambda must be enclosed in parentheses. For example: Call (Sub() <statement>) () Single-line statement lambdas must include exactly one statement. Static local variables cannot be declared inside lambda expressions. Expanded Properties cannot be initialized. Auto-implemented properties cannot have parameters. Auto-implemented properties cannot be WriteOnly. 'If' operator requires either two or three operands. Cannot initialize the type '{0}' with a collection initializer because it is not a collection type. Cannot initialize the type '{0}' with a collection initializer because it does not have an accessible 'Add' method. An Object Initializer and a Collection Initializer cannot be combined in the same initialization. An aggregate collection initializer entry must contain at least one element. XML end element must be preceded by a matching start element. 'On Error' and 'Resume' cannot appear inside a lambda expression. Keywords 'Out' and 'In' can only be used in interface and delegate declarations. The literal string ']]>' is not allowed in element content. Inappropriate use of '{0}' keyword in a module. Type or namespace '{0}' is not defined. Using DirectCast operator to cast a floating-point value to the same type is not supported. Using DirectCast operator to cast a value-type to the same type is obsolete. Using DirectCast operator to cast a value-type to the same type is obsolete Unreachable code detected. Unreachable code detected Function '{0}' doesn't return a value on all code paths. Are you missing a 'Return' statement? Function doesn't return a value on all code paths Operator '{0}' doesn't return a value on all code paths. Are you missing a 'Return' statement? Operator doesn't return a value on all code paths Property '{0}' doesn't return a value on all code paths. Are you missing a 'Return' statement? Property doesn't return a value on all code paths Global namespace may not be nested in another namespace. '{0}' cannot expose type '{1}' in {2} '{3}' through {4} '{5}'. '{0}' cannot be referenced because it is not a valid assembly. '{0}' cannot be implemented by a {1} property. {0}: {1} Cannot infer a common type because more than one type is possible. Cannot infer a common type because more than one type is possible; 'Object' assumed. Cannot infer a common type because more than one type is possible Cannot infer a common type, and Option Strict On does not allow 'Object' to be assumed. Cannot infer a common type; 'Object' assumed. Cannot infer a common type Cannot infer a common type. Error extracting public key from file '{0}': {1} Error extracting public key from container '{0}': {1} Friend access was granted by '{0}', but the public key of the output assembly does not match that specified by the attribute in the granting assembly. Friend access was granted by '{0}', but the strong name signing state of the output assembly does not match that of the granting assembly. Public sign was specified and requires a public key, but no public key was specified Public signing is not supported for netmodules. Attribute '{0}' is ignored when public signing is specified. Attribute is ignored when public signing is specified. Delay signing was specified and requires a public key, but no public key was specified. Delay signing was specified and requires a public key, but no public key was specified Key file '{0}' is missing the private key needed for signing. Error signing assembly '{0}': {1} The specified version string does not conform to the required format - major[.minor[.build|*[.revision|*]]] The specified version string does not conform to the recommended format - major.minor.build.revision The specified version string does not conform to the recommended format The specified version string does not conform to the recommended format - major.minor.build.revision (without wildcards) Executables cannot be satellite assemblies; culture should always be empty The entry point of the program is global script code; ignoring '{0}' entry point. The entry point of the program is global script code; ignoring entry point The xmlns attribute has special meaning and should not be written with a prefix. The xmlns attribute has special meaning and should not be written with a prefix It is not recommended to have attributes named xmlns. Did you mean to write 'xmlns:{0}' to define a prefix named '{0}'? It is not recommended to have attributes named xmlns Expected a single script (.vbx file) The assembly name '{0}' is reserved and cannot be used as a reference in an interactive session #R is only allowed in scripts You cannot declare Namespace in script code You cannot use '{0}' in top-level script code Cannot infer a return type. Consider adding an 'As' clause to specify the return type. Cannot infer a return type; 'Object' assumed. Cannot infer a return type Cannot infer a return type because more than one type is possible; 'Object' assumed. Cannot infer a return type because more than one type is possible Cannot infer a return type. Consider adding an 'As' clause to specify the return type. Cannot infer a return type because more than one type is possible. Consider adding an 'As' clause to specify the return type. The command line switch '{0}' is not yet implemented and was ignored. Command line switch is not yet implemented Cannot infer an element type, and Option Strict On does not allow 'Object' to be assumed. Specifying the type of the array might correct this error. Cannot infer an element type. Specifying the type of the array might correct this error. Cannot infer an element type because more than one type is possible. Specifying the type of the array might correct this error. Cannot infer an element type; 'Object' assumed. Cannot infer an element type Cannot infer an element type because more than one type is possible; 'Object' assumed. Cannot infer an element type because more than one type is possible Data type of '{0}' in '{1}' could not be inferred. '{2}' assumed. Data type could not be inferred Option Strict On does not allow implicit conversions from '{0}' to '{1}' because the conversion is ambiguous. Conversion from '{0}' to '{1}' may be ambiguous. Conversion may be ambiguous '{0}' cannot be converted to '{1}'. Consider using '{2}' instead. '{0}' cannot be converted to '{1}'. Consider using '{2}' instead. Type cannot be converted to target collection type '{4}' cannot be converted to '{5}' because '{0}' is not derived from '{1}', as required for the 'In' generic parameter '{2}' in '{3}'. '{4}' cannot be converted to '{5}' because '{0}' is not derived from '{1}', as required for the 'Out' generic parameter '{2}' in '{3}'. Implicit conversion from '{4}' to '{5}'; this conversion may fail because '{0}' is not derived from '{1}', as required for the 'In' generic parameter '{2}' in '{3}'. Implicit conversion; this conversion may fail because the target type is not derived from the source type, as required for 'In' generic parameter Implicit conversion from '{4}' to '{5}'; this conversion may fail because '{0}' is not derived from '{1}', as required for the 'Out' generic parameter '{2}' in '{3}'. Implicit conversion; this conversion may fail because the target type is not derived from the source type, as required for 'Out' generic parameter '{0}' cannot be converted to '{1}'. Consider changing the '{2}' in the definition of '{3}' to an In type parameter, 'In {2}'. '{0}' cannot be converted to '{1}'. Consider changing the '{2}' in the definition of '{3}' to an Out type parameter, 'Out {2}'. '{0}' cannot be converted to '{1}'. Consider changing the '{2}' in the definition of '{3}' to an In type parameter, 'In {2}'. Type cannot be converted to target type '{0}' cannot be converted to '{1}'. Consider changing the '{2}' in the definition of '{3}' to an Out type parameter, 'Out {2}'. Type cannot be converted to target type Interface '{0}' is ambiguous with another implemented interface '{1}' due to the 'In' and 'Out' parameters in '{2}'. Interface is ambiguous with another implemented interface due to 'In' and 'Out' parameters Enumerations, classes, and structures cannot be declared in an interface that has an 'In' or 'Out' type parameter. Event definitions with parameters are not allowed in an interface such as '{0}' that has 'In' or 'Out' type parameters. Consider declaring the event by using a delegate type which is not defined within '{0}'. For example, 'Event {1} As Action(Of ...)'. Type '{0}' cannot be used in this context because 'In' and 'Out' type parameters cannot be used for ByRef parameter types, and '{0}' is an 'In' type parameter. Type '{0}' cannot be used in '{1}' because 'In' and 'Out' type parameters cannot be made nullable, and '{0}' is an 'In' type parameter. Type '{0}' cannot be used in this context because '{0}' is an 'In' type parameter. Type '{0}' cannot be used for the '{1}' in '{2}' in this context because '{0}' is an 'In' type parameter. Type '{0}' cannot be used in '{1}' in this context because '{0}' is an 'In' type parameter. Type '{0}' cannot be used for the '{2}' of '{3}' in '{1}' in this context because '{0}' is an 'In' type parameter. Type '{0}' cannot be used as a property type in this context because '{0}' is an 'In' type parameter and the property is not marked WriteOnly. Type '{0}' cannot be used as a ReadOnly property type because '{0}' is an 'In' type parameter. Type '{0}' cannot be used as a return type because '{0}' is an 'In' type parameter. Type '{0}' cannot be used in this context because 'In' and 'Out' type parameters cannot be used for ByRef parameter types, and '{0}' is an 'Out' type parameter. Type '{0}' cannot be used as a ByVal parameter type because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used as a generic type constraint because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used in '{1}' because 'In' and 'Out' type parameters cannot be made nullable, and '{0}' is an 'Out' type parameter. Type '{0}' cannot be used in this context because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used for the '{1}' in '{2}' in this context because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used in '{1}' in this context because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used for the '{2}' of '{3}' in '{1}' in this context because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used as a property type in this context because '{0}' is an 'Out' type parameter and the property is not marked ReadOnly. Type '{0}' cannot be used as a WriteOnly property type because '{0}' is an 'Out' type parameter. Type '{0}' cannot be used in this context because both the context and the definition of '{0}' are nested within interface '{1}', and '{1}' has 'In' or 'Out' type parameters. Consider moving the definition of '{0}' outside of '{1}'. Type '{0}' cannot be used for the '{2}' in '{3}' in this context because both the context and the definition of '{0}' are nested within interface '{1}', and '{1}' has 'In' or 'Out' type parameters. Consider moving the definition of '{0}' outside of '{1}'. Type '{0}' cannot be used in '{2}' in this context because both the context and the definition of '{0}' are nested within interface '{1}', and '{1}' has 'In' or 'Out' type parameters. Consider moving the definition of '{0}' outside of '{1}'. Type '{0}' cannot be used for the '{3}' of '{4}' in '{2}' in this context because both the context and the definition of '{0}' are nested within interface '{1}', and '{1}' has 'In' or 'Out' type parameters. Consider moving the definition of '{0}' outside o ... Parameter not valid for the specified unmanaged type. Unmanaged type '{0}' not valid for fields. Unmanaged type '{0}' is only valid for fields. Attribute parameter '{0}' must be specified. Attribute parameter '{0}' or '{1}' must be specified. Conflicts with '{0}', which is implicitly declared for '{1}' in {2} '{3}'. <project settings> Attributes applied on a return type of a WriteOnly Property have no effect. Attributes applied on a return type of a WriteOnly Property have no effect Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations. Cannot find the interop type that matches the embedded type '{0}'. Are you missing an assembly reference? Reference to class '{0}' is not allowed when its assembly is configured to embed interop types. Embedded interop structure '{0}' can contain only public instance fields. Interop type '{0}' cannot be embedded because it is missing the required '{1}' attribute. Cannot embed interop types from assembly '{0}' because it is missing the '{1}' attribute. Cannot embed interop type '{0}' found in both assembly '{1}' and '{2}'. Consider disabling the embedding of interop types. Cannot embed interop types from assembly '{0}' because it is missing either the '{1}' attribute or the '{2}' attribute. Interface '{0}' has an invalid source interface which is required to embed event '{1}'. Source interface '{0}' is missing method '{1}', which is required to embed event '{2}'. Nested type '{0}' cannot be embedded. Embedding the interop type '{0}' from assembly '{1}' causes a name clash in the current assembly. Consider disabling the embedding of interop types. Embedded interop method '{0}' contains a body. 'Await' may only be used in a query expression within the first collection expression of the initial 'From' clause or within the collection expression of a 'Join' clause. 'Await' requires that the type '{0}' have a suitable GetAwaiter method. 'Await' requires that the return type '{0}' of '{1}.GetAwaiter()' have suitable IsCompleted, OnCompleted and GetResult members, and implement INotifyCompletion or ICriticalNotifyCompletion. '{0}' does not implement '{1}'. Cannot await Nothing. Consider awaiting 'Task.Yield()' instead. Async methods cannot have ByRef parameters. 'Async' and 'Iterator' modifiers cannot be used together. The implicit return variable of an Iterator or Async method cannot be accessed. 'Return' statements in this Async method cannot return a value since the return type of the function is 'Task'. Consider changing the function's return type to 'Task(Of T)'. Since this is an async method, the return expression must be of type '{0}' rather than 'Task(Of {0})'. The 'Async' modifier can only be used on Subs, or on Functions that return Task or Task(Of T). '{0}' does not return a Task and cannot be awaited. Consider changing it to an Async Function. 'Only the 'Async' or 'Iterator' modifier is valid on a lambda. 'Await' can only be used within an Async method. Consider marking this method with the 'Async' modifier and changing its return type to 'Task(Of {0})'. 'Await' can only be used within an Async method. Consider marking this method with the 'Async' modifier and changing its return type to 'Task'. 'Await' can only be used within an Async lambda expression. Consider marking this lambda expression with the 'Async' modifier. 'Await' can only be used when contained within a method or lambda expression marked with the 'Async' modifier. Statement lambdas cannot be converted to expression trees. Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the Await operator to the result of the call. Because this call is not awaited, execution of the current method continues before the call is completed Loop control variable cannot include an 'Await'. Static variables cannot appear inside Async or Iterator methods. '{0}' cannot be used as a parameter type for an Iterator or Async method. Constructor must not have the 'Async' modifier. '{0}' cannot be declared 'Partial' because it has the 'Async' modifier. 'On Error' and 'Resume' cannot appear inside async or iterator methods. Lambdas with the 'Async' or 'Iterator' modifiers cannot be converted to expression trees. Variable of restricted type '{0}' cannot be declared in an Async or Iterator method. 'Await' cannot be used inside a 'Catch' statement, a 'Finally' statement, or a 'SyncLock' statement. This async method lacks 'Await' operators and so will run synchronously. Consider using the 'Await' operator to await non-blocking API calls, or 'Await Task.Run(...)' to do CPU-bound work on a background thread. This async method lacks 'Await' operators and so will run synchronously The Task returned from this Async Function will be dropped, and any exceptions in it ignored. Consider changing it to an Async Sub so its exceptions are propagated. The Task returned from this Async Function will be dropped, and any exceptions in it ignored Async and Iterator methods are not allowed in a [Class|Structure|Interface|Module] that has the 'SecurityCritical' or 'SecuritySafeCritical' attribute. Security attribute '{0}' cannot be applied to an Async or Iterator method. 'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to an Async or Iterator method. 'MethodImplOptions.Synchronized' cannot be applied to an Async method. The 'Main' method cannot be marked 'Async'. Some overloads here take an Async Function rather than an Async Sub. Consider either using an Async Function, or casting this Async Sub explicitly to the desired type. Some overloads here take an Async Function rather than an Async Sub MyGroupCollectionAttribute cannot be applied to itself. Literal expected. Event declarations that target WinMD must specify a delegate type. Add an As clause to the event declaration. Event '{0}' cannot implement a Windows Runtime event '{1}' and a regular .NET event '{2}' Event '{0}' cannot implement event '{1}' on interface '{2}' because the parameters of their 'RemoveHandler' methods do not match. The type of the 'AddHandler' method's parameter must be the same as the type of the event. In a Windows Runtime event, the type of the 'RemoveHandler' method parameter must be 'EventRegistrationToken' '{0}.{1}' from 'implements {2}' is already implemented by the base class '{3}'. Re-implementation of Windows Runtime Interface '{4}' is not allowed '{0}.{1}' is already implemented by the base class '{2}'. Re-implementation of Windows Runtime Interface '{3}' is not allowed Iterator methods cannot have ByRef parameters. Single-line lambdas cannot have the 'Iterator' modifier. Use a multiline lambda instead. Iterator functions must return either IEnumerable(Of T), or IEnumerator(Of T), or the non-generic forms IEnumerable or IEnumerator. To return a value from an Iterator function, use 'Yield' rather than 'Return'. 'Yield' can only be used in a method marked with the 'Iterator' modifier. 'Yield' cannot be used inside a 'Catch' statement or a 'Finally' statement. The AddHandler for Windows Runtime event '{0}' doesn't return a value on all code paths. Are you missing a 'Return' statement? The AddHandler for Windows Runtime event doesn't return a value on all code paths Optional parameter of a method '{0}' does not have the same default value as the corresponding parameter of the partial method '{1}'. Parameter of a method '{0}' differs by ParamArray modifier from the corresponding parameter of the partial method '{1}'. Module name '{0}' stored in '{1}' must match its filename. Invalid module name: {0} Attribute '{0}' from module '{1}' will be ignored in favor of the instance appearing in source. Attribute from module will be ignored in favor of the instance appearing in source Attribute '{0}' given in a source file conflicts with option '{1}'. Referenced assembly '{0}' does not have a strong name. Referenced assembly does not have a strong name Invalid signature public key specified in AssemblySignatureKeyAttribute. Type '{0}' conflicts with public type defined in added module '{1}'. Type '{0}' exported from module '{1}' conflicts with type declared in primary module of this assembly. Type '{0}' exported from module '{1}' conflicts with type '{2}' exported from module '{3}'. Referenced assembly '{0}' has different culture setting of '{1}'. Referenced assembly has different culture setting Agnostic assembly cannot have a processor specific module '{0}'. Assembly and module '{0}' cannot target different processors. Referenced assembly '{0}' targets a different processor. Referenced assembly targets a different processor Cryptographic failure while creating hashes. Conflicting options specified: Win32 resource file; Win32 manifest. Forwarded type '{0}' conflicts with type declared in primary module of this assembly. Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' forwarded to assembly '{3}'. Name '{0}' exceeds the maximum length allowed in metadata. Reference to '{0}' netmodule missing. Module '{0}' is already defined in this assembly. Each module must have a unique filename. Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' exported from module '{3}'. Adding assembly reference '{0}' Adding embedded assembly reference '{0}' Adding module reference '{0}' Type '{0}' does not inherit the generic type parameters of its container. Failure writing debug information: {0} The parameter has multiple distinct default values. The field has multiple distinct constant values. Cannot continue since the edit includes a reference to an embedded type: '{0}'. Member '{0}' added during the current debug session can only be accessed from within its declaring assembly '{1}'. '{0}' is an unsupported .NET module. '{0}' is an unsupported event. Properties can not have type arguments IdentifierSyntax not within syntax tree AnonymousObjectCreationExpressionSyntax not within syntax tree FieldInitializerSyntax not within syntax tree The system cannot find the path specified There are no pointer types in VB. There are no function pointer types in VB. There is no dynamic type in VB. There are no native integer types in VB. variableSyntax not within syntax tree AggregateSyntax not within syntax tree FunctionSyntax not within syntax tree Position is not within syntax tree RangeVariableSyntax not within syntax tree DeclarationSyntax not within syntax tree StatementOrExpression is not an ExecutableStatementSyntax or an ExpressionSyntax DeclarationSyntax not within tree TypeParameter not within tree not within tree Location must be provided in order to provide minimal type qualification. SemanticModel must be provided in order to provide minimal type qualification. the number of type parameters and arguments should be the same Cannot link resource files when building a module Not a VB symbol. Elements cannot be null. Unused import clause. Unused import statement. Expected a {0} SemanticModel. Position must be within span of the syntax tree. Syntax node to be speculated cannot belong to a syntax tree from the current compilation. Chaining speculative semantic model is not supported. You should create a speculative model from the non-speculative ParentModel. Microsoft (R) Visual Basic Compiler {0} version {1} Copyright (C) Microsoft Corporation. All rights reserved. Supported language versions: Visual Basic Compiler Options - OUTPUT FILE - -out:<file> Specifies the output file name. -target:exe Create a console application (default). ( ... Local name '{0}' is too long for PDB. Consider shortening or compiling without /debug. Local name is too long for PDB Import string '{0}' is too long for PDB. Consider shortening or compiling without /debug. Import string is too long for PDB XML comment has a tag with a 'cref' attribute '{0}' that bound to a type parameter. Use the <typeparamref> tag instead. XML comment has a tag with a 'cref' attribute that bound to a type parameter Linked netmodule metadata must provide a full PE image: '{0}'. An instance of analyzer {0} cannot be created from {1} : {2}. Instance of analyzer cannot be created The assembly {0} does not contain any analyzers. Assembly does not contain any analyzers Unable to load analyzer assembly {0} : {1}. Unable to load analyzer assembly Skipping some types in analyzer assembly {0} due to a ReflectionTypeLoadException : {1}. Skip loading types in analyzer assembly that fail due to a ReflectionTypeLoadException Error reading ruleset file {0} - {1} {0} is not supported in current project type. The RequiredAttribute attribute is not permitted on Visual Basic types. Cannot emit debug information for a source text without encoding. '{0}' is not a valid format specifier Preprocessor constant '{0}' of type '{1}' is not supported, only primitive types are allowed. 'Warning' expected. '{0}' cannot be made nullable. Leading '?' can only appear inside a 'With' statement, but not inside an object member initializer. A null propagating operator cannot be converted into an expression tree. An expression is too long or complex to compile This expression does not have a name. This sub-expression cannot be used inside NameOf argument. Method type arguments unexpected. SearchCriteria is expected. Assembly culture strings may not contain embedded NUL characters. There is an error in a referenced assembly '{0}'. Format specifier may not contain trailing whitespace. Alignment value is outside of the supported range. There were one or more errors emitting a call to {0}.{1}. Method or its return type may be missing or malformed. Unused import clause Unused import statement Length of String constant resulting from concatenation exceeds System.Int32.MaxValue. Try splitting the string into multiple constants. Visual Basic {0} does not support {1}. Error reading debug information for '{0}' array literal expressions async methods or lambdas auto-implemented properties readonly auto-implemented properties variance collection initializers comments after line continuation declaring a Global namespace iterators implicit line continuation multi-line lambda expressions 'Sub' lambda expressions null conditional operations 'nameof' expressions region directives within method bodies or regions crossing boundaries of declaration blocks multiline string literals CObj in attribute arguments line continuation comments TypeOf IsNot expression year-first date literals warning directives partial modules partial interfaces implementing read-only or write-only property with read-write property digit separators binary literals tuples Private Protected Debug entry point must be a definition of a method declared in the current compilation. The pathmap option was incorrectly formatted. Syntax tree should be created from a submission. Combined length of user strings used by the program exceeds allowed limit. Try to decrease use of string or XML literals. An error occurred while writing the output file: {0} Option '{0}' must be an absolute path. /sourcelink switch is only supported when emitting PDB. Tuple element names must be unique. The tuple element name '{0}' is ignored because a different name or no name is specified by the target type '{1}'. The tuple element name is ignored because a different name or no name is specified by the assignment target. Tuple element name '{0}' is only allowed at position {1}. Tuple element name '{0}' is disallowed at any position. Tuple must contain at least two elements. Cannot define a class or member that utilizes tuples because the compiler required type '{0}' cannot be found. Are you missing a reference? Cannot reference 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explicitly. Use the tuple syntax to define tuple names. An expression tree may not contain a call to a method or property that returns by reference. /embed switch is only supported when emitting a PDB. Invalid instrumentation kind: {0} Invalid hash algorithm name: '{0}' Error writing to XML documentation file: {0} Invalid assembly name: {0} Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'. Merge conflict marker encountered Do not use refout when using refonly. Cannot compile net modules when using /refout or /refonly. Named argument '{0}' is used out-of-position but is followed by an unnamed argument Provided documentation mode is unsupported or invalid: '{0}'. Provided language version is unsupported or invalid: '{0}'. Provided source code kind is unsupported or invalid: '{0}' Tuple element name '{0}' is inferred. Please use language version {1} or greater to access an element by its inferred name. '{0}' is for evaluation purposes only and is subject to change or removal in future updates. Type is for evaluation purposes only and is subject to change or removal in future updates. '{0}' is for evaluation purposes only and is subject to change or removal in future updates: '{1}'. Type is for evaluation purposes only and is subject to change or removal in future updates. Unable to read debug information of method '{0}' (token 0x{1:X8}) from assembly '{2}': {3} {0} is not a valid Visual Basic conversion expression {0} is not a valid Visual Basic argument leading digit separator Predefined type '{0}' is declared in multiple referenced assemblies: '{1}' and '{2}' {0} is not a valid Visual Basic compound assignment operation interpolated strings unconstrained type parameters in binary conditional expressions Multiple analyzer config files cannot be in the same directory ('{0}'). Type '{0}' cannot be embedded because it has a non-abstract member. Consider setting the 'Embed Interop Types' property to false. Type '{0}' cannot be embedded because it has a re-abstraction of a member from base interface. Consider setting the 'Embed Interop Types' property to false. Command-line syntax error: '{0}' is not a valid value for the '{1}' option. The value must be of the form '{2}'. Target runtime doesn't support default interface implementation. Target runtime doesn't support 'Protected', 'Protected Friend', or 'Private Protected' accessibility for a member of an interface. '{0}' is not supported in VB. Attribute is not supported in VB Generator '{0}' failed to generate source. It will not contribute to the output and compilation errors may occur as a result. Exception was of type '{1}' with message '{2}'. {3} Generator failed to generate source. Generator '{0}' failed to initialize. It will not contribute to the output and compilation errors may occur as a result. Exception was of type '{1}' with message '{2}'. {3} Generator failed to initialize. The assembly '{0}' containing type '{1}' references .NET Framework, which is not supported. The loaded assembly references .NET Framework, which is not supported. Analyzer assembly '{0}' cannot be used because it references version '{1}' of the compiler, which is newer than the currently running version '{2}'. Analyzer assembly cannot be used because it references a newer version of the compiler than the currently running version. assigning to or passing 'ByRef' properties with init-only setters recognizing 'unmanaged' constraint Init-only property '{0}' can only be assigned by an object member initializer, or on 'Me', 'MyClass` or 'MyBase' in an instance constructor. '{0}' cannot override init-only '{1}'. Init-only '{0}' cannot be implemented. 'UnmanagedCallersOnly' attribute is not supported. caller argument expression The CallerArgumentExpressionAttribute applied to parameter '{0}' will have no effect because it's self-referential. The CallerArgumentExpressionAttribute applied to parameter will have no effect because it's self-referential. The CallerArgumentExpressionAttribute applied to parameter '{0}' will have no effect. It is applied with an invalid parameter name. The CallerArgumentExpressionAttribute applied to parameter will have no effect. It is applied with an invalid parameter name. A shared abstract or virtual interface member cannot be accessed. {0} '{1}' cannot implement interface '{3}' because it contains shared abstract or virtual '{2}'. '{0}' requires compiler feature '{1}', which is not supported by this version of the Visual Basic compiler. 'System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute' is reserved for compiler usage only. Analyzer reference '{0}' specified multiple times Analyzer reference specified multiple times Required member '{0}' must be set in the object initializer or attribute arguments. Cannot inherit from '{0}' because it has required members. The required members list for '{0}' is malformed and cannot be interpreted. '{2}' cannot satisfy the 'New' constraint on parameter '{1}' in the generic type or or method '{0}' because '{2}' has required members. 'System.Runtime.CompilerServices.RequiredMemberAttribute' is reserved for compiler usage only. A call to a method or property that returns by reference may not be used as 'With' statement expression in an async or iterator method, or if referenced implicitly in a lambda. '{0}' is defined in assembly '{1}'. The diagnosticId argument to the 'Experimental' attribute must be a valid identifier A value of type 'System.Threading.Lock' is not supported in SyncLock. Consider manually calling 'Enter' and 'Exit' methods in a Try/Finally block instead. A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in SyncLock statement. A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in SyncLock statement. The specified version string contains wildcards, which are not compatible with determinism. Either remove wildcards from the version string, or disable determinism for this compilation The type name '{0}' is reserved to be used by the compiler. Cannot use 'OverloadResolutionPriorityAttribute' on an overriding member. Cannot use 'OverloadResolutionPriorityAttribute' on this member. overload resolution priority The type 'Microsoft.CodeAnalysis.EmbeddedAttribute' must be non-generic, Friend, NotInheritable, have a Public parameterless constructor, inherit from System.Attribute, and be able to be applied to any type DiagnosticAnalyzer for VB compiler's syntax/semantic/compilation diagnostics. An array of child bound nodes. Note that any of the child nodes may be null. Returns Nothing if parent is not known. Creates the Lazy IOperation from a delegate creation operand or a bound conversion operand, handling when the conversion is actually a delegate creation. Gets the operand from a BoundConversion, compensating for if the conversion is a user-defined conversion Addition Visual Basic syntax extension methods. Determines if is of a specified kind. The source trivia. The syntax kind to test for. if the trivia is of the specified kind; otherwise, . Determines if is of a specified kind. The source token. The syntax kind to test for. if the token is of the specified kind; otherwise, . Determines if is of a specified kind. The Source node. The syntax kind to test for. if the node is of the specified kind; otherwise, . Determines if is of a specified kind. The source node or token. The syntax kind to test for. if the node or token is of the specified kind; otherwise, . Returns the index of the first node of a specified kind in the node list. Node list. The to find. Returns non-negative index if the list contains a node which matches , -1 otherwise. Tests whether a list contains node of a particular kind. The to test for. Returns true if the list contains a token which matches Returns the index of the first node of a specified kind in the node list. Node list. The to find. Returns non-negative index if the list contains a node which matches , -1 otherwise. Tests whether a list contains node of a particular kind. The to test for. Returns true if the list contains a token which matches Returns the index of the first trivia of a specified kind in the trivia list. Trivia list. The to find. Returns non-negative index if the list contains a trivia which matches , -1 otherwise. Tests whether a list contains trivia of a particular kind. The to test for. Returns true if the list contains a trivia which matches Returns the index of the first token of a specified kind in the token list. Token list. The to find. Returns non-negative index if the list contains a token which matches , -1 otherwise. Tests whether a list contains token of a particular kind. The to test for. Returns true if the list contains a token which matches