bolt

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 unindexed
• 1.11.0.0 unindexed

Definitions (1,644)

src/syntax/bind.bend

• def plan.ginnerthe mode a group's insides are read in; MStop when they mean nothing here
• def plan.gnextthe mode the rest is read in after a group
• def plan.gkeepsdo the names a group binds stay bound after it?
• def plan.kmodethe mode a statement's header is read in
• def plan.bmodethe mode a statement's body is read in
• def plan.mark_headis the scope recorded before a statement's header?
• def plan.mark_bodyis the scope recorded between a statement's header and its body?
• def plan.markedthe scope recorded onto the output, when it is
• def plan.scopeddoes a statement close its scope for the statements after it?
• def plan.snextthe mode the statements after a statement are read in
• def walkthe walk: one node in one mode, against an environment.
• def lstripleading spaces dropped
• def strippeda line's text without its indentation
• def note_fora declaration carries its own note; anything else shows the line that bound it, which `text` gives only when it is asked for
• def annotate.aheadthe lines from line `line` on, given the lines from line `at` on: a step forward from where the last binder was, not a walk from the first line
• def annotate.headthe first line of these, or ""
• def annotate.backa line read from the first, for a binder behind the last one
• def annotate.goevery binder with its note filled.
• def annotateevery binder with its note filled
• def finishthe gathered output, in source order and annotated
• def of_treethe binding structure of a parsed source
• def boundthe binding structure of a source
• type Sitewhere a name is: a binder, or a use of one
• def coversdoes the name at (l, c) cover the position (line, col)?
• def bind_at.gothe binder whose name covers a position; hit: the one before binds did, so the search stops there
• def bind_atthe binder whose name covers a position
• def use_at.gothe use whose name covers a position; hit: the one before uses did, so the search stops there
• def use_atthe use whose name covers a position
• def at.or
• def atthe site at a position
• def binder.gothe binder at a position (a use's target, or the binder itself); hit: the one before binds was, so the search stops there
• def binderthe binder at a position (a use's target, or the binder itself)
• def visible.gothe names in scope at a line: those of the statement on it, else of the nearest statement above
• def notedthe scopes hold binders before their notes were filled: read each back
• def beforedoes (l1, c1) come before (l2, c2) in the source?
• def seek.stopdoes a cursor's head sit at or after a position (the seek stops there)?
• def seekthe binders from the first one not before a position on; the binders are in source order, so none this drops sits at the position.
• def seek.headthe binder at the head of a cursor, when it sits at the position
• def refresh.goeach binder of an environment, outermost first, with the note its annotated twin carries, pushed onto acc (so acc ends innermost first again).
• def refresheach binder of an environment, with the note its annotated twin carries
• def visiblethe names in scope at a line: those of the statement on it, else of the nearest statement above
• def sites.goevery position a binder is named at: its own, then its uses'
• def sitesevery position a binder is named at: its own, then its uses'
• def item_sites.bindsevery position an item of the file is named at: its declaration, then its uses
• def item_sites.uses
• def item_sitesevery position an item of the file is named at: its declaration, then its uses
• def named_sites.goevery position a name not of this file is used at (Base, or through an alias)
• def named_sitesevery position a name not of this file is used at (Base, or through an alias)

src/syntax/lex.bend

• type TokKindthe kinds; TName is a plain name (lowercase, undotted): what a pattern can bind
• type Tokline and col are 0-based, of the token's first char
• type Classwhat a char is, for the machine
• type Modewhat the machine is inside of; Fresh: the next char starts a token
• type Stbuf and toks are reversed; (sl, sc) is where the current token started
• def classify.gothe class of a code point, given the class any other character would get.
• def classifya char's class
• def continuesdoes a char of this class continue the token the machine is inside of?
• def afterthe mode after a char that continued the token
• def begin.modethe mode and the kind of the token a char starts
• def begin.kind
• def wordthe buffered chars as a string, in order
• def is_keywordis the text one of Bend's keywords?
• def upper_firstdoes the text start with a capital?
• def refine_namea whole name's kind
• def refine_opa whole operator's kind
• def refinea name's or an operator's kind, once its text is whole
• def flushthe token so far joins the others
• def is_newlineis the char a line break, '\n'?
• def stepone char: it continues the current token, or starts a new one.
• def runevery char, in order
• def finishthe tokens once the chars are over, the last one flushed
• def tokensa source as tokens
• def text.gothe tokens' texts, back to back: the source
• def textthe tokens' texts, back to back: the source
• def is_openan opening bracket?
• def is_commaa comma?
• def is_nameany identifier: a name, a keyword, a dotted or a capitalized one, `_`
• def is_nla newline?
• def significantnot space, a newline or a comment
• def is_stra string literal?

src/syntax/outline.bend

• type ItemKindwhat an item is; ILocal is not read from a source, it is how the server offers a binder as a candidate
• type Itemline is 0-based; sig is the header text (a def's through its `:`, a law's whole block, a constructor's line); doc is the comment block right above; path is an import's target
• type Clswhat a line is, by its first chars
• type ModePending: a def's header that has not reached its `:`, or a law's block
• type Stdoc and out are reversed
• def classify.kwthe class when the prefix matches, else other
• def classify.rebuildleading spaces (reversed) in front of the rest of the line
• def classify.white.hitan indented line when the first char is a space, else other
• def classify.whitewhitespace after a leading space-class char.
• def classify.white.entera line whose first char is whitespace
• def classify.ktype`type `, once the `t` is known
• def classify.klaw`law `, else `type `
• def classify.kat`@unsafe def `, else `law `
• def classify.kdef`def `, else `@unsafe def `
• def classify.kimp`import `, else `def `
• def classify.keysa column-0 keyword, from the first character's code
• def classify.hold.keysa column-0 keyword keeps the line; the class comes from its first character
• def classify.hold.gap.keepwhitespace that is not a leading space keeps the line: the class may not
• def classify.hold.gapa leading space is blank or indented, and that class already carries the line
• def classify.hold.spacewhitespace, else a keyword
• def classify.hold.hasha comment keeps its text; anything else is whitespace or a keyword