Table of Contents

Namespace RDCore.SDK.Platform.Protocol

Classes

ArrayBoundDescriptor

The bounds of one dimension of a fixed-size array.

ArrayDescriptor

What an array declaration says beyond its element type (MS-VBAL §5.2.3.1.3): whether it is fixed-size, and the bounds it was declared with.

CompileErrorDto

A compile error, as it travels: what a diagnostics extension needs to say it.

ConstantDescriptor

A transport-friendly projection of a Const declaration — a module-level VBConstantMemberSymbol or a procedure-local VBLocalConstantSymbol.

ConversionFactDto

A ConversionFact, as it travels.

DebugAck

What a request about the program that is being debugged answers when it has no result of its own.

DebugBreakpoint

A breakpoint that was set.

DebugBreakpointsResult

The breakpoints that were set, in the order they were asked for.

DebugEdit

An edit made while a program waits that is not applied to it.

DebugEditStatusResult

The edits made while a program waits that are not applied to it.

DebugEvaluateResult

What an expression came to.

DebugGotoResult

Where a program that waits goes on from, after a request to move it.

DebugStackFrame

One activation of a procedure.

DebugStackResult

The call stack of a program that waits.

DebugVariable

A variable, or a part of one.

DebugVariablesResult

The variables that were asked for.

DeclarationFactDto

A DeclarationFact, as it travels.

DefinitionDescriptor

A transport-friendly projection of one SymbolDefinition — a single declaration site of a member declared in more than one conditional-compilation branch.

DescribeResult

The answer to rdcore/semantics/describe: the symbol the name at the position binds to, and the facts of the expression the position is in.

DescribedError

The compile error of an expression, as it is described.

DescribedExpression

What is known of an expression, wherever it is written: the facts ExpressionDescription and the assistant tools' description share.

DescribedSymbol

What is known of a symbol, wherever its declaration is written: the facts SymbolDescription and the assistant tools' description share.

DescribedSymbols

What a SymbolDescription says of a symbol of the language model: its kind, its scope, and the facts the environment host has of its declaration.

DidRenameWorkspaceFilesParams

workspace/didRenameFiles (LSP 3.17 §Workspace, DidRenameFiles Notification): a client renamed or moved files or folders.

DiscardResult

What taking a module out of the session took out. The same result answers both hops of the request.

DocumentDiagnosticPullParams

textDocument/diagnostic (LSP 3.17 §Document Diagnostics), as a client of the platform sends it: the request an editor pulls the diagnostics of a document with, whose report is read as a DocumentDiagnosticPullReport.

DocumentDiagnosticPullReport

The report a DocumentDiagnosticPullParams is answered with: a full one, with the diagnostics, or an unchanged one, without.

ExecuteResult

The result of a run. The same result answers both hops — the language server passes the host's answer back to the client unchanged, except for a parse that never reached the host at all.

ExecuteStackFrame

One activation of the call stack a run-time error was raised on.

ExpressionDescription

The facts of an expression, as rdcore/semantics/describe answers them.

ExpressionFactDto

An ExpressionFact, as it travels.

ExternalDescriptor

The Declare-statement metadata of an external member.

FakeAction

What a call a FakeRow matches does.

FakeArgumentMatcher

What one argument of a call must be for a FakeRow to match it.

FakeAssignment

A ByRef argument that a faked call writes.

FakeInvocation

Which calls of its target a FakeRow matches.

FakeInvocationRecord

One call of a target a row of the fakes names: what a test verifies a call against.

FakeRow

One fake: which calls of a target it matches, and what it does with them.

FakesTable

The fakes of a run: which external calls are answered in place of running, and how.

FakesTableDelta

A change to a run's fakes while it runs: what a test written in VBA sets up (Fakes.MsgBox.Returns vbYes) reaches the table this way, with the answer of the call that set it up.

InputBoxParams

What a program asks for in an InputBox, as it travels to whoever asks.

InputBoxResult

What was typed in an InputBox, that it was cancelled, or that nobody was asked.

ListSettingValueParams

Request rdcore/settings/listValue (ListSettingValue): asks the client to add an item to the list of a setting, or to remove one from it, in the user's settings of the platform or in the settings of a workspace. The client answers a ListSettingValueResult.

ListSettingValueRequest

ListSettingValueParams as a request of rdcore/settings/listValue, which the language server sends a client.

ListSettingValueResult

What a client did with an item it was asked to add to a list, or to remove from it.

LocalDescriptor

A transport-friendly projection of a VBLocalVariableSymbol — one Dim or Static of a procedure.

MessageBoxParams

What a program shows in a MsgBox, as it travels to whoever shows it.

MessageBoxResult

Which button closed a MsgBox, or that nobody was asked.

ModuleOutline

The answer to rdcore/semantics/outline: the declarations of a document's module, in the order they are written.

ModuleSemanticsDto

A ModuleSemanticModel, as it travels.

OperatorFactDto

An OperatorFact, as it travels: an operation of an operator, or the access of a member (MemberAccessFact).

OutlineEntry

A declaration of a module's outline, as rdcore/semantics/outline answers it.

OutlinedDeclaration

What is known of a declaration of a module's outline, wherever it is written: the facts OutlineEntry and the assistant tools' entry share.

OutlinedModule

What is known of a module, wherever it is written: the facts ModuleOutline and the assistant tools' outline share.

ParameterDescriptor

A transport-friendly projection of a VBParameterSymbol.

PeekResult

What was at the address.

PlatformInitializeParams

Request for rdcore/platform/initialize (PlatformInitialize), the non-LSP handshake that follows LSP's initialize/initialized exchange and keeps the LSP layer pure LSP: the caller tells the component it connected to what it expects, once LSP's initialize is answered; answered a PlatformInitializeResult. A client of the language server sends it as the platform's own components do of one another.

PlatformInitializeRequest

PlatformInitializeParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with. Sent by ChildConnection once LSP's initialize is answered.

PlatformInitializeResult

Response: what the component actually is and provides.

PlatformJson

System.Text.Json (de)serialization for rich platform payloads that ride a JSON-RPC method as an opaque string.

PlatformJsonEnvelope

A JSON-RPC request or response body whose real payload is a System.Text.Json string (see PlatformJson). Flat by design so the transport's own serializer round-trips it.

PokeResult

Whether the byte went in.

ProcedureSemanticsDto

A ProcedureSemanticModel, as it travels.

RDCoreInitializationOptions

What a client says of itself to a server in the initializationOptions of the LSP initialize request. That part of the protocol exists for exactly this: the settings of a server that no standard capability describes.

RDCoreNotificationHandler<TNotification>

The base class for a platform protocol JSON-RPC notification.

RDCoreRequestHandler<TRequest, TResponse>

The base class for a platform protocol JSON-RPC request.

RefactorAnswer

The user's answer to one choice.

RefactorApplyParams

Applies a refactoring of a document's range with its user's answers (rdcore/refactor/apply), and is answered the edit it makes (RefactorWorkspaceEdit). A refactoring that is refused, or whose answers it refuses, is answered with an error (RequestFailed, -32803) whose message says why, in the language of the user interface.

RefactorApplyRequest

RefactorApplyParams as a request of rdcore/refactor/apply, answered with a RefactorWorkspaceEdit: the type a language server's handler of the request takes.

RefactorCheckIdentifierRequest

RefactorIdentifierCheckParams as a request of rdcore/refactor/checkIdentifier, answered with a RefactorIdentifierCheckResult: the type a language server's handler of the request takes.

RefactorChoice

One thing a refactoring asks its user, with its default.

RefactorDocumentEdit

The edits of one document (LSP 3.17 §TextDocumentEdit).

RefactorIdentifierCheckParams

Asks the language server about an identifier the user is typing in answer to a refactoring's Name choice, before the refactoring is applied (rdcore/refactor/checkIdentifier): whether it can be declared where the refactoring declares it, and what it would hide. It is answered with the notices (RefactorIdentifierCheckResult), which a dialog shows beside the identifier as its user types it.

RefactorIdentifierCheckResult

What the identifiers a user typed for a refactoring raise: one the code cannot declare where the refactoring declares it, or one that hides another declaration.

RefactorItem

One item of a list a refactoring asks about: a parameter, a member.

RefactorItemAnswer

The user's answers for one item of a list.

RefactorNotice

Why a refactoring is refused, what it would change of what the code does, or what the user should know of it.

RefactorOption

One option of a choice.

RefactorPrepareParams

Asks the language server what a refactoring of a document's range would ask its user, and what it would refuse or change, before it is applied (rdcore/refactor/prepare).

RefactorPrepareRequest

RefactorPrepareParams as a request of rdcore/refactor/prepare, answered with a RefactorPrepareResult: the type a language server's handler of the request takes.

RefactorPrepareResult

What a refactoring asks its user, with the answer it takes by default to each question, and what it refuses or would change.

RefactorTextEdit

One edit of a document's text (LSP 3.17 §TextEdit).

RefactorWorkspaceEdit

What a refactoring changes in the workspace (LSP 3.17 §WorkspaceEdit): the documents it creates, then the edits of each document, which a client applies as one change.

RubberduckIndenterSettingsApplyParams

Request rdcore/formatting/indenterSettings/apply (RubberduckIndenterSettingsApply): asks the client to take the indenter settings it read as its own settings. The client answers a RubberduckIndenterSettingsApplyResult.

RubberduckIndenterSettingsApplyRequest

RubberduckIndenterSettingsApplyParams as a request of rdcore/formatting/indenterSettings/apply.

RubberduckIndenterSettingsApplyResult

What a client did with the settings it was asked to apply.

RubberduckIndenterSettingsParams

Request rdcore/formatting/indenterSettings (RubberduckIndenterSettings): asks the client for the indenter settings its user had in Rubberduck, as Rubberduck has them. The client answers a RubberduckIndenterSettingsResult.

RubberduckIndenterSettingsReply

RubberduckIndenterSettingsResult as the answer to RubberduckIndenterSettingsRequest.

RubberduckIndenterSettingsRequest

RubberduckIndenterSettingsParams as a request of rdcore/formatting/indenterSettings.

RubberduckIndenterSettingsResult

What a client read of the indenter settings of Rubberduck, as Rubberduck has them: { "source": "RubberduckConfig", "values": { "IndentSpaces": "4" }, "tabWidth": null }.

RunValue

A constant on the wire: the value of a data row's argument, of a fake's answer, or of an argument a faked call was given.

RuntimeErrorDto

A run-time error that code is guaranteed to raise, as it travels.

RuntimeFactsDto

A RuntimeFacts, as it travels.

SemanticsDescribeParams

The parameters of rdcore/semantics/describe: a position of a document, which the language server describes the name or expression written at.

SemanticsDescribeRequest

SemanticsDescribeParams as a request of rdcore/semantics/describe, answered with a DescribeResult.

SemanticsOutlineParams

The parameters of rdcore/semantics/outline: a document, whose module the language server outlines.

SemanticsOutlineRequest

SemanticsOutlineParams as a request of rdcore/semantics/outline, answered with a ModuleOutline.

SemanticsPayload

The semantic facts of one or more modules, as they travel (Json).

SessionAnalyzeParams

Request for rdcore/session/analyze: a client asks the language server to analyze a module it supplies and report what is wrong with it, without running anything.

SessionAnalyzeResult

What the platform found in the module.

SessionBreakpointLine

A breakpoint as a client asks for it: a line, whether it is on, and the condition it waits on, as the person typed it.

SessionCommandCompletion

A command of a client that is being typed at its prompt: the verb, which the client registered, and its arguments as they are typed.

SessionCommandsParams

Request for rdcore/session/commands: a client registers the verbs of its own commands with the language server, described (VerbDescriptor), so that what is typed after one at its prompt is completed as its descriptor says.

SessionCommandsResult

What the language server made of the verbs a client registered.

SessionCompletionParams

Request for rdcore/session/completion: a client asks the language server what can be written at a position of a module it supplies - the completion list of a line typed at a prompt.

SessionDebugBreakpointsParams

Request for rdcore/session/debug/breakpoints: sets the lines of a module that a program under a debugger waits at, replacing the breakpoints it had; answered a DebugBreakpointsResult.

SessionDebugBreakpointsRequest

SessionDebugBreakpointsParams as a request of rdcore/session/debug/breakpoints.

SessionDebugEditStatusParams

Request for rdcore/session/debug/editStatus: which edits made while a program waits are not applied to it, and why; answered a DebugEditStatusResult.

SessionDebugEditStatusRequest

SessionDebugEditStatusParams as a request of rdcore/session/debug/editStatus.

SessionDebugErrorBreakParams

Request for rdcore/session/debug/errorBreak: sets which run-time errors a program under a debugger (Debug) waits at, where they are raised; answered a DebugAck.

SessionDebugErrorBreakRequest

SessionDebugErrorBreakParams as a request of rdcore/session/debug/errorBreak, handled as it arrives (HandledOnArrivalAttribute): the mode applies from the next error the running program raises.

SessionDebugEvaluateParams

Request for rdcore/session/debug/evaluate: the value of an expression, written as text, in an activation of the program that waits; answered a DebugEvaluateResult. The language server parses it and has the host evaluate it.

SessionDebugEvaluateRequest

SessionDebugEvaluateParams as a request of rdcore/session/debug/evaluate.

SessionDebugExecuteParams

Request for rdcore/session/debug/execute: runs a statement, written as text, in an activation of the program that waits - the answer to a line typed in the immediate window of a procedure that is stopped; answered a DebugEvaluateResult with no value. The language server parses it and has the host run it.

SessionDebugExecuteRequest

SessionDebugExecuteParams as a request of rdcore/session/debug/execute.

SessionDebugGotoParams

Request for rdcore/session/debug/goto: moves the point the program that waits goes on from (Set Next Statement), within the procedure it waits in; answered a DebugGotoResult. Nothing runs.

SessionDebugGotoRequest

SessionDebugGotoParams as a request of rdcore/session/debug/goto.

SessionDebugPauseParams

Request for rdcore/session/debug/pause: stops the program that is running, at the next instruction, so that it waits there; answered a DebugAck. The request that is running the program answers Suspended.

SessionDebugPauseRequest

SessionDebugPauseParams as a request of rdcore/session/debug/pause, handled as it arrives (HandledOnArrivalAttribute).

SessionDebugResumeParams

Request for rdcore/session/debug/resume: a client asks the language server to go on with the program it ran under a debugger (Debug) that waits where it stopped, and is answered an ExecuteResult as of the next time the program waits or is over.

SessionDebugResumeRequest

SessionDebugResumeParams as a request of rdcore/session/debug/resume.

SessionDebugStackParams

Request for rdcore/session/debug/stack: the activations of the program that waits, innermost first; answered a DebugStackResult.

SessionDebugStackRequest

SessionDebugStackParams as a request of rdcore/session/debug/stack.

SessionDebugStoppedNotification

SessionDebugStoppedParams as a notification of rdcore/session/debug/stopped, which the language server sends a client.

SessionDebugStoppedParams

Notification rdcore/session/debug/stopped: the language server tells a client that expects the SessionStops capability that the handler of an event stopped while no program runs (a Stop, a breakpoint, a failed Debug.Assert, an error a debugger waits at), and waits where it stopped.

SessionDebugTerminateParams

Request for rdcore/session/debug/terminate: ends the program that is running or waits; answered a DebugAck. Its variables stay, as they do when a program is stopped, unless Wipe says they go.

SessionDebugTerminateRequest

SessionDebugTerminateParams as a request of rdcore/session/debug/terminate, handled as it arrives (HandledOnArrivalAttribute).

SessionDebugVariablesParams

Request for rdcore/session/debug/variables: the variables of an activation of the program that waits, or the parts of one of them; answered a DebugVariablesResult.

SessionDebugVariablesRequest

SessionDebugVariablesParams as a request of rdcore/session/debug/variables.

SessionDiagnostic

One finding, flattened for a client that renders lines of text rather than editor decorations.

SessionDiscardParams

Request for rdcore/session/discard: a client asks the language server to take a module it supplied out of the platform's runtime session.

SessionDiscardRequest

SessionDiscardParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionExecuteParams

Request for rdcore/session/execute: a client asks the language server to run one procedure of a module it supplies.

SessionExecuteRequest

SessionExecuteParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionInputBoxParams

Request rdcore/session/interaction/inputBox, which a client handles: the language server asks a client that said it shows dialogs (the SessionInteraction capability) to answer a program's InputBox, and is answered an InputBoxResult.

SessionInputBoxRequest

SessionInputBoxParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionMemoryStatus

The allocation and fragmentation statistics of the runtime session's memory space, as plain numbers: the computed ones too, so that a client renders them without deriving anything.

SessionMemoryStatusExtensions

Projects a session allocator's statistics onto the wire.

SessionMessageBoxParams

Request rdcore/session/interaction/msgBox, which a client handles: the language server asks a client that said it shows dialogs (the SessionInteraction capability) to answer a program's MsgBox, and is answered a MessageBoxResult.

SessionMessageBoxRequest

SessionMessageBoxParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionPeekParams

Request for rdcore/session/memory/peek: a client reads one byte of the runtime session's memory.

SessionPeekRequest

SessionPeekParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionPokeParams

Request for rdcore/session/memory/poke: a client writes one byte of the runtime session's memory.

SessionPokeRequest

SessionPokeParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionSemanticTokensParams

Request for rdcore/session/semanticTokens: a client asks the language server what the tokens of code fragments it supplies are - the colours of a condition, or of a line typed at a prompt.

SessionSemanticTokensResult

The answer to SessionSemanticTokensParams.

SessionSignatureHelpParams

Request for rdcore/session/signatureHelp: a client asks the language server what the call being written at a position of a module it supplies takes - the signature help of a line typed at a prompt.

SessionStatusParams

Request for rdcore/session/status: a client asks the language server for the state of the platform's runtime session.

SessionStatusRequest

SessionStatusParams as the platform's JSON-RPC handlers and senders know it: the method it is a request of, and what it is answered with.

SessionStatusResult

The state of the platform's runtime session. The same result answers both hops of the status request: the language server passes the host's answer through unchanged.

StatementFactDto

A StatementFact, as it travels.

SymbolDescription

The symbol a name binds to, as rdcore/semantics/describe answers it.

SymbolDescriptor

A transport-friendly projection of one declared member Symbol. Declared types travel as names, not resolved VBTypes — the environment host is the resolution authority.

SymbolDescriptorReader

Reconstructs runtime member Symbols from the descriptors carried by a DefineSymbolsParams. The inverse of the language server's descriptor projection; one trivial method per SymbolDescriptorKind, mirroring the language server's SymbolBuilder. Declared types are bound through a caller-supplied resolver so the same call path binds real types once the environment host composes a project/library resolver: a name the resolver returns null for stays VBUnknownType.

ToolCallReply

ToolCallResult as the answer to ToolCallRequest.

ToolCallRequest

ToolCallParams as a request of rdcore/tools/call, answered with a ToolCallReply: the type a language server's handler of the request takes.

ToolsListReply

ToolsListResult as the answer to ToolsListRequest.

ToolsListRequest

ToolsListParams as a request of rdcore/tools/list, answered with a ToolsListReply: the type a language server's handler of the request takes.

WorkspaceFileRename

A file or folder a client renamed (LSP 3.17 FileRename).

Enums

DebugEditKind

What an edit made while a program waits is to it, when it is not applied.

DebugVariableScope

Which variables of a frame.

DescribedScope

Where a symbol is declared, which says where its name can be written.

DescribedSymbolKind

What a symbol is: a declaration of the workspace or of a library.

ExecutionOutcome

How a run ended.

FakeActionKind

What a matched call does.

FakeInvocationKind

The kind of a FakeInvocation: every call of the target, or the nth.

FakeMatch

How a FakeArgumentMatcher compares an argument.

RefactorChoiceKind

What a choice of a refactoring is made of.

RefactorNoticeKind

What a notice of a refactoring says.

RubberduckIndenterSettingsSource

Where the indenter settings a client read were found.

SessionDiagnosticSeverity

How bad a SessionDiagnostic is. Mirrors LSP's own severities so a client that has an editor and a client that has a prompt rank the same finding the same way.

SettingScope

Where a setting's value is kept, which says what it applies to.

SymbolDescriptorKind

The member-symbol kinds a SymbolDescriptor can carry. Mirrors the subset of MemberKind the language server's AST symbol provider emits, split so Property accessors and Enum/Type members each map to one runtime symbol type.