bend-lint-pack

Releases (1)

• 0.1.1.0 indexed

Definitions (166)

all.bend

• def main

common.bend

• type SeenOwners of facts =============== A global name that owns facts (a def, a law, a type, a constructor), and where its first fact sits.
• type OwnersThe owners of the facts read so far: in reverse order of first appearance, and as a set.
• def Owners.empty
• def Owners.pick
• def Owners.seen
• def Owners.noteTemplate instances are skipped, so a template is seen once, as itself.
• def Owners.add
• def Owners.collectA fold_facts step: records each fact's owner.
• def Owners.orderedThe owners in order of first appearance.
• def diagDiagnostics ===========
• def whenOne diagnostic when `hit`, else none.
• def onto
• def localNames ===== The part of a global name after its file's namespace: `b:helper` is `helper`.
• def is_packageWhether a global name comes from a BendHub package (`0x<hash>/file:name`): not this project's code.
• def hasWhether a name is in a set.
• def Edges.add.ofGraph of references between globals ==================================== Lists of names under a name, last added first.
• def Edges.add
• def Edges.ofThe names under `key`, last added first; the map is only read.
• type GraphWhat the facts say: the owners, `edges` (owner -> names it references, with repeats), and `into` (name -> owners that reference it, with repeats).
• def Graph.empty
• def Graph.link
• def Graph.add.of
• def base.of
• def baseA template call refers to an instance, `twice~0`, and a template's own parameter is `twice~f`: both are the template, `twice`.
• def Graph.add
• def Graph.collectA fold_facts step.
• def Laws.nameLaws ==== Laws are specs, not code: a def that fills one is a proof.
• def Laws.line
• def Laws.add
• def Laws.lines
• def Laws.scanThe names of the laws written in the `sources` whose paths are in `paths`.
• def Laws.sourcesA call evaluates its arguments, so a file is split into lines only through a match: Base is long.
• def Paths.ofThe paths the owners' spans are in.
• def Laws.ofThe local names of every law in the program's own files.
• def Laws.hasWhether `owner` is a law or the proof that fills one.
• def Bodies.putOwners that have a checked body =============================== Defs and laws have one; types and constructors do not.
• def Bodies.of
• def Entry.hitEntry lists: `a, b, prefix*` ============================ Whether the entry `e` names `name`: the same, or, if it ends in `*`, a prefix of it.
• def Entry.anyWhether some entry names `owner`, as written or without its namespace.
• def Entry.trim
• def Entry.parseA comma-separated option as a list.
• def Nodes.putThe program's own code ====================== The defs of the program: owners with a checked body that are not laws, proofs or package code.
• def Nodes.is
• def Nodes.of
• type ProgEverything a graph rule reads: the owners in order, the reference maps, the set of defs, and the local names of the laws.
• def Prog.with
• def Prog.build
• def Prog.owners
• def Prog.of
• type CountDegrees ======= A count of the different names that are defs, and the names counted.
• def Count.put
• def Count.add
• def Count.n
• def distinct
• def degree.go
• def degreeThe number of different defs of the program that `owner` has under it in `m` (the defs it uses, for `edges`; the defs that use it, for `into`).
• type ScopeWhere to report =============== By default a rule reports only in the linted file, though it reads the whole program: the imported files are libraries to it.
• def root_path
• def Scope.of
• def in_root
• def Scope.has
• def scoped.put
• def scopedThe owners a rule reports on.

complexity/cognitive.bend

• def id
• def facts
• def walk
• def walk.allEach of `cs` the same way.
• def walk.armsThe children of a Mat: the first is an arm body, one level down; the others continue the chain.
• def walk.step
• def walk.shape
• def score.of
• def message
• def judge
• def run
• def main

complexity/cyclomatic.bend

• def id
• def facts
• type TallyNode kinds seen under a def.
• def bump.kind
• def walk
• def walk.all
• def walk.shape
• def complexity1 + Mat - Efq; never below 1.
• def score.of
• def message
• def judge
• def run
• def main

dead/def.bend

• def id
• def facts
• def is_rootEntry points ============
• def roots
• def reach
• def reach.go
• def messageFindings ========
• def is_dead
• def report
• def nothing
• def verdict.go`none`: there is no entry point.