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/lint/world.bend

def texta file's text, or None when it could not be read, is a directory, or is not read yet

src/lsp/checker/answer.bend

type Answera checker's answer for a file: the diagnostics bend reported, or that bend could not be run on it at all
def errorsan answer's diagnostics: none when bend could not be run
def dieda run a signal cut short: what bend reported before it died, or, when that is nothing, no check at all
def answer.tagthe answer a tag gives: bend ran (`r`), a signal killed it (`s`), or neither, and it could not be run; each error placed by the checked file's names, when they are known
def answerexec's text read: its tag, then what bend printed, as diagnostics placed by the checked file's names
def proveda LAWS.bend's errors, settled by its PROOF.bend's answer: none when that checks clean, and no check at all when bend could not be run on it
type Checkereffect service: the checker's answer for the file at a path (bend.bend's service is the real one)
def checkthe checker's answer for the file at a path, from a checker service

src/lsp/checker/argv.bend

type Runa run of bend: the file it is given and the flag after it
def flagthe flag of a run
def run_ofthe run that checks a file: `bend <path> --check-only`
def only_todosonly the open-laws report ("1 TODO found", "N TODOs found"), and nothing else
def proof_paththe PROOF.bend beside a LAWS.bend
def followupBy convention LAWS.bend states its laws as open claims and PROOF.bend, beside it, fills them: alone, LAWS.bend always has TODOs.

src/lsp/checker/bend.bend

def bendcheck.exechow `bend <path> <flag>` went, one tag char, then everything it printed.
def launchwhat a run of bend answered, tag first; every run is argv.bend's, so it checks and never runs main
def settlethe first report, settled by the run that follows it (a LAWS.bend's PROOF.bend), when argv.bend gives one
def checkedthe diagnostics of a run, settled by the run that follows it
def settleda run's answer: its diagnostics settled when bend ran, else no check
def checkbend's report on the file, its errors placed by the names of the file's items (read from the file bend read; unknown when it cannot be read)
def servicethe checker as a service (answer.bend's Checker)

src/lsp/checker/names.bend

def ns.leada path without its leading `./`s
def nsan import's namespace: its path, without a leading `./` or its `.bend`
def key.ofthe key of a name that opens with `head.`: through the import aliased head when there is one, else the name as written
def key.partsan item's key, among the file's items
def keyan item's key: bend's name for it
def keysthe keys of the items, imports aside, onto acc (in no particular order)
def ofthe names bend gives a file's items, when its text could be read

src/lsp/docs.bend

type Docan open document: its URI, the text the editor shows, the checker's errors from its last run, and the role marks read with them
def delthe documents without the one at a URI
def errorsthe checker's errors for a document, none when it is not open
def marksthe role marks kept for a document, none when it is not open
def seta document's text set (opened, or changed); its errors and marks stay
def getthe text of an open document, when it is open
def set_checkeda document's errors set, from a run of the checker, with the marks read beside it

src/lsp/enc.bend

type Encthe encodings the server speaks
def namean encoding's name on the wire
def offersdoes a list of encodings (JSON cells) offer utf-32?
def cellsthe cells of an array, JNil when it is not one
def chosenthe encoding for utf-32 offered or not
def negotiatethe encoding initialize settles on: utf-32 when the client's general.positionEncodings offers it, else UTF-16, LSP's default
def widedoes a char take two UTF-16 code units (it lies past U+FFFF)?
def units.stepthe units a char and the ones after it take: two for a wide char, else one
def unitsthe UTF-16 code units the first n chars of a line take; a column past the line's end counts one unit a column
def points.skipthe units left after a char, from 1+p units: p after a narrow one, one fewer after a wide one (none when the offset falls inside its pair)
def pointsthe chars the first u UTF-16 code units of a line cover; an offset inside a pair covers its char, and one past the line's end counts one column a unit
def out.ofa code-point column of a line in an encoding
def into.ofan encoding's column of a line as a code-point column
def wide_indoes a line hold a char past U+FFFF?
def wide_anydoes any line hold one?
def narrowedthe encoding a document's columns convert by: UTF-16 on lines with no wide char counts exactly as utf-32 does (LAWS.bend's enc_narrow), so such a document converts as utf-32 and never looks a line up
type Colsa document as the boundary sees it: the encoding its columns convert by and the text's lines
def cols.ofa document's lines under an encoding
def colsa document's text under an encoding
def charsa line's chars, none past the end
def out.cola code-point column of a line's chars, sent in an encoding
def out.ata code-point column of a document's line, sent in an encoding; utf-32 never looks the line up
def outa code-point column sent in the negotiated encoding
def into.cola column of a line's chars read in an encoding, as a code-point column
def into.ata column of a document's line read in an encoding; utf-32 never looks the line up
def intoa column read in the negotiated encoding, as a code-point column

src/lsp/files/disk.bend

def slurp.end
def slurp.cut
def slurp.more
def slurp.next
def slurpthe whole file, read in chunks until one is empty, or the fuel is
def read.opened
def reada file's text, or None when it cannot be opened
def base_path.of
def base_pathBase, where bend's installer puts it
def cwdthe working directory, as the lint's walk names it
def entriesa directory's entries, as the lint's walk lists them
def newthe real file system

src/lsp/files/service.bend

type Fileseffect service: a file's text, where Base is, the working directory, and a directory's entries
def readNone when the file cannot be read
def base_paththe path of Base, from a files service
def cwdthe working directory, from the root; "" when it cannot be named
def entriesa directory's entries, none when it cannot be opened
def read_allevery path read, in order (a missing file is a None)

src/lsp/frame.bend

type Decthe decoder's state: continuation bytes still owed, the code point so far, the chars so far (reversed)
def decode.leada lead byte, by its high nibble; a stray continuation byte stands for itself
def decode.more
def decode.step
def decode.run
def decode.end
def decodeUTF-8 bytes as a string (a bad byte is skipped)
def widthhow many bytes a code point takes
def encode.chara code point's bytes, by its width, in front of the rest
def encode.one
def encode.go
def encodea string as UTF-8 bytes
type Digita decimal digit
def digit.codea digit's char code, '0' to '9'
def digit.readthe digit a char code stands for, if it is one
def ticka count one more (digits least significant first)
def tick.bya count plus a char's width in bytes
def byte_counthow many UTF-8 bytes the chars take, counted on from ds
def count.showa count's digits, most significant first, in front of acc
def count.zerois the count zero?