bolt

Search uses release 1.27.0.0 · 1,644 definitions

Releases (13)

1.27.0.0 indexed
1.26.0.0 unindexed
1.25.0.0 unindexed
1.24.0.0 unindexed
1.23.0.0 unindexed
1.22.0.0 unindexed
1.21.0.0 unindexed
1.20.0.0 unindexed
1.19.0.0 unindexed
1.18.0.0 unindexed
1.17.0.0 unindexed
1.12.0.0 invalid
expected a fresh constructor name (duplicate declaration: Ready)

at src/lsp/frame.bend:295
10 files do not load
1.11.0.0 invalid
expected a fresh constructor name (duplicate declaration: Ready)

at src/lsp/frame.bend:295
10 files do not load

Definitions (1,644)

src/lsp/server.bend

def pub.closeclose: the document forgotten, and an empty list published
def pub.configsthe texts of a document's bolt.bend candidates, as the files hold them
def pub.read.answera file's text as an answer
def pub.answerone question of the planner's, answered from the files: a directory's entries, or a file's text (a directory reads as no text)
def pub.answersevery question answered, in order
def pub.world.morethe World with more answers in it
def pub.world.stepthe planner's questions answered and the World gone round again, or the World as it is once the planner asks none
def pub.world.gothe World `bolt <path>` reads, gathered as src/lint.bend gathers it: the planner's questions answered until it asks none, under the same fuel
def pub.seenthe role marks the tree's imports give a document, as `bolt <path>` reads them
def pub.openedopen, on the checker's run on the file on disk
def pub.savedsave, on the checker's run on the file on disk
def pub.changedchange: the linter only
def hover.of
def definition.of
def col_inthe column a request's position names, read in the negotiated encoding of the document's text
def hoveredhover at a request's position
def defineddefinition at a request's position
def complete.with
def completethe candidates for the name being typed at a position
def references.of
def rename.ofonly a name bound in the document renames; the editor shows the refusal
def referencesevery position of the name at a position
def renamedthe edit renaming the name at a position, or a refusal
def semanticthe document's semantic tokens
def symbolsthe document's symbols
def workthe work behind a method: what the checker, the files and the documents give it.
def encodingthe encoding after a message: initialize settles it (enc.bend's negotiate); every other message keeps it
def handleone message: its method's work, then step's decision on it
def decodeda parsed message, or null when it did not parse
def send_allevery reply sent, in order
def nextthe loop goes on with the documents, unless the message said to quit
def answerthe replies sent, then the loop goes on
def turn.msga message handled under the encoding it leaves, and answered
def turnone message body handled and answered; none means the peer is gone
def gotwhat recv gave: the handle and maybe a body
def serve.go
def serveserves until exit, the peer's end, or the fuel's (a message each), in UTF-16 until initialize negotiates

src/lsp/transport/service.bend

type Transporteffect service over a handle H: receive a body, send a body, each handing the handle back
def recvthe next message's body; None when the peer is gone
def senda body, through a transport

src/lsp/transport/stdio.bend

type Stdiothe process's stdin and stdout, and the bytes read but not yet framed
def recv.grownno bytes means the peer closed the pipe
def recv.fed
def recv.read
def recv.ona whole message is cut off the buffer; short of one, read and look again
def recv.loop
def recvthe fuel bounds the reads one message may take
def send.done
def senda body, framed and written
def stdio.fda File for a descriptor the process already holds.
def openthe process's descriptors 0 and 1, wrapped
def newthe transport over stdio

src/noqa.bend

type Markone noqa comment: its line and column (0-based) and width, and the codes it names, none for a bare one
type Marksa file's noqa comments
type Clswhat a char is to the code list: a space, a comma, a letter or digit, or anything else
def clsa char's class
type Phasewhere the code list reader stands: before a code (spaces allowed), inside one, after one (spaces, then a comma or the list's end), or past the list
type Rdthe reader: where it stands, the code it is reading (its chars, the last first), and the codes read (the last first)
def wordthe chars read, the last first, as a code
def step.beforebefore a code: a space waits, a letter or digit starts one, anything else ends the list
def step.insideinside a code: a letter or digit extends it; a space, a comma or anything else ends it, and a comma expects the next
def step.afterafter a code: a space waits, a comma expects the next, anything else ends the list
def step.atthe reader after one more char
def stepthe reader after one more char
def runthe reader after the text
def finish.atthe codes read, in order, the one still being read included
def finishthe codes read, in order
def codesthe codes a text after `noqa:` names
def leadthe text after its leading spaces
def mark.resta comment's text past `noqa`: a mark naming the codes after a `:`, a bare one at the end or before a space, and none for anything else (`noqas`)
def mark.worda comment's text past `#` and its spaces: a mark when it opens with `noqa`
def mark.texta comment's text: a mark when it is `#`, any spaces, then `noqa`
def mark.ofa comment token's mark, when it is one; any other token has none
def marksthe marks among the tokens, in order
def filea file's marks, from its tokens
def of_srcseach source's marks, in order
def namedthe codes include this one
def on_linea mark on the line names the code
def silenceda mark of the file at the path, on the line, names the code
def keepthe graded findings no mark silences, in order

src/paths.bend

def base.gothe last of the segments, or the one before when there are none
def basea path's last segment
def testedis some segment but the last exactly `tests`?
def is_testis the file under a `tests` directory?
def is_lawsis it a LAWS.bend?
def is_proofis it a PROOF.bend?
def is_law_fileis it a LAWS.bend or a PROOF.bend?

src/rchars.bend

def ontothe buffer's chars, first read first, then acc
def textthe buffer's chars, first read first

src/role.bend

type Rolewhat a file is to the laws
def of_patha file's role by its name alone: a LAWS.bend, a PROOF.bend, or neither
def is_lawsis it a law file?
def is_proofis it a proof file?
def is_law_fileis it a law file or a proof file?
def skipa rule that has nothing to say of a law or proof file: its findings on a file told its role, none on one of those
def reachedwhat a file on the laws' side is: a law file when a LAWS.bend reaches it, else a proof file
type Factone file as the walk reads it: its normalized path, what it imports, its role by name, and whether it is a package's entry (a main.bend)
def facta parsed file read down to its fact
def fact.texta file's fact read from its text alone: lexed and outlined for its imports, never parsed, so a file read only for its place in the graph costs little
def factsevery file's fact, in order