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/rules/pedantic/rewalk.bend

def namesevery name under the node
def lhs_namesthe names a let binds: every name left of its `=` or `<-`
def last_poswhere a let's names take effect: its last token, after the right-hand side
def bind_allone binding per name, at the let's end
def bind_atone binding per name, at this position
def bindsthe lets of one straight piece; a case arm is not part of it
def before(l1, c1) comes before (l2, c2)
def counthow many lets of this name take effect before this position
def stampwhich binding of each name an argument reads: two calls with the same text read the same values only when no let of those names sits between them
def gatherevery expensive call, wide unless the call is indexed on the spot; its arguments are their text and which let of each name they read
def add_seena second name on the left
def fold_namesnames inside a field group, which makes the let a field read
def eatthe left of `=`
def note_howa field when the left has a group, otherwise a let of that name
def note_nonenothing, and the maybe is consumed
def note_somethe note when the right-hand side is a call
def note_rhsthe note for a call, when the left is exactly one name
def rhs_ofthe tokens after `=`
def note_froma let or a field binding of exactly one call
def note_sta let or a field binding of exactly one call
def retag_oneone site, retagged when it is the let's call
def note_linea note's line
def note_cola note's column
def note_how_ofa note's how
def retagsites whose callee is this let's call take its how
def retag_mayretag when the statement is a let of a call
def applylets of a call retag that call
def pinnedthis position was marked a collection argument
def pin_widea wide call at a marked position becomes a slot; a let or a field stays
def pin_howa wide call at a marked position becomes a slot
def pin_oneone site
def pinmarked collection arguments become slots
type Rateda site, with whether its result is read for a single value over the piece
def rate_oneone site, rated: the piece is walked for it here, once
def rateeach site, rated once, so the reports below compare ratings and never walk the piece again: a walk per site, not one per pair of sites
def other_goanother site has the same callee and the same arguments, and keeps the whole result
def earliera narrow site of this call already reported
def report_freshthe finding when no earlier narrow site took this call
def report_narthe finding, when this is the first narrow site of a duplicated call
def report_dupthe finding when a duplicate exists and this site is the first narrow one
def report_oneone site
def reportthe first narrow site of each duplicated call
def localfindings in one straight region; a case arm is not part of it
def visiteach case arm on its own, so two arms are not one path
def check.go
def checkthe rule

src/rules/pedantic/strict.bend

def logicis the operator `&&` or `||`?
def seg_op.endsa comma or a `=>`: the end of a stretch
def seg_op.orthis leaf's `&&` or `||`, or one further on in the stretch
def seg_opdoes the chain, up to its first top-level comma or `=>`, hold `&&` or `||`?
def inneris the group after a name an operand: the stretch is hot, or it is the `(` of `Bool.and` or `Bool.or`
def calla name, then a group: a finding when the name is the def, the group a `(` call and the stretch hot, then what the group and the rest report
def leafa leaf read by its kind: past a comma, past a `=>`, or past any other token; only the branch taken runs
def walkthe self-calls in operands: outer is whether the enclosing group is an operand, hot whether the current comma segment is; a `=>` starts a lambda body, hot only by its own `&&`/`||`.
def check.go
def checkthe rule

src/rules/pedantic/tail.bend

def bareis a statement's chain exactly a call of the name, `name(..)`?
def walkthe self-calls not in tail position; skip: the chain is a bare self-call
def check.go
def checkthe rule

src/rules/perf/chars.bend

def literalone when a case pattern opens with a character literal, else zero
def tallythe character-literal arms among a match's statements
def reporta finding when the match holds more character literals than is cheap
def on_stmta statement: a match is tallied
def walkevery statement, at any depth
def checkthe rule

src/rules/perf/strings.bend

type Tallythe string arms of a match, and their characters
def closesdoes the text end on a closing quote, its escapes read as a backslash and the one char after it?
def openedpast its opening char, do the chars end on a closing quote?
def terminatedis a string token closed: past its opening quote, does it end on a quote no backslash escapes?
def literalthe characters of the string a case pattern opens with, if it does and the string is closed
def oneone for a string arm, else zero
def sizea string arm's characters, else zero
def tallythe string arms among a match's statements
def reporta finding when the match's strings are too long in all
def on_stmta statement: a match is tallied
def walkevery statement, at any depth
def checkthe rule

src/rules/style/doc.bend

def needsdoes an item of this kind need a comment?
def exempt`main`, and helpers named `x.go`
def whatan item's kind, for the message
def check.afterreading down, does a comment block end right above the next line?
def check.leadreading lines 0 to nn - 1 down from ok: does a comment block end right above line nn, past a run of attribute lines?
def check.aboveis there a comment line right above line nn, or right above the attribute lines right above it?
def check.go
def lines.go
def linesthe lines of a source, each one that starts inside a string literal read as empty: it is text, never a comment line
def checkthe rule
def check.rolethe rule, told the file's role (src/role.bend): a proof file is skipped

src/rules/style/noqa.bend

def projecta project rule's code
def judgeda code this run can judge: any, over the whole tree; a per-file rule's (or no rule's) otherwise
def known.insome row of the table has the code
def knownthe code is a rule's
def useda graded finding at the path, on the line, has the code
def say.barewhat a bare mark is told
def saywhat an unused code is told: a rule's, or no rule's
def check.codesone finding for each code judged here that silences nothing on its line
def check.marka mark's findings: one when it is bare, else one per code that silences nothing
def checkevery mark of the file at the path, against the run's graded findings

src/rules/style/param.bend

def check.letterone character, and a capital: a type parameter