bend-lint-pack Releases (1): 0.1.1.0 0x7294c9a1db4be6346e88202032984e02 indexed https://jend.leeeet.dev/files.txt?path=bend-lint-pack@0.1.1.0 Definitions (166, 1 to 100 shown): All.main (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/all.bend&name=main) def main() -> IO(Unit): Common.Seen (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Seen) # Owners of facts # =============== # A global name that owns facts (a def, a law, a type, a constructor), and where its first fact sits. type Seen is Data: Seen{owner: String, span: Maybe<&2, Lint.Span>} Common.Owners (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners) # The owners of the facts read so far: in reverse order of first appearance, and as a set. type Owners is Data: Owners{list: List<&2, Seen>, set: Set()} Common.Owners.empty (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.empty) def Owners.empty() -> Owners: Common.Owners.pick (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.pick) def Owners.pick( list: List<&2, Seen>, +set: Set(), had: Bool, +owner: String, inst: Bool, span: Maybe<&2, Lint.Span> ) -> Owners: Common.Owners.seen (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.seen) def Owners.seen( list: List<&2, Seen>, r: Set() & Bool, +owner: String, inst: Bool, span: Maybe<&2, Lint.Span> ) -> Owners: Common.Owners.note (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.note) # Template instances are skipped, so a template is seen once, as itself. def Owners.note(acc: Owners, +owner: String, inst: Bool, span: Maybe<&2, Lint.Span>) -> Owners: Common.Owners.add (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.add) def Owners.add(acc: Owners, v: Lint.View) -> Owners: Common.Owners.collect (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.collect) # A fold_facts step: records each fact's owner. def Owners.collect(acc: Owners, +f: Lint.Fact) -> IO(Owners): Common.Owners.ordered (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Owners.ordered) # The owners in order of first appearance. def Owners.ordered(o: Owners) -> List<&2, Seen>: Common.diag (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=diag) # Diagnostics # =========== def diag(sev: Lint.Severity, message: String, span: Maybe<&2, Lint.Span>) -> Lint.Diag: Common.when (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=when) # One diagnostic when `hit`, else none. def when(hit: Bool, d: Lint.Diag) -> List<&2, Lint.Diag>: Common.onto (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=onto) def onto(xs: List<&2, Lint.Diag>, out: List<&2, Lint.Diag>) -> List<&2, Lint.Diag>: Common.local (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=local) # Names # ===== # The part of a global name after its file's namespace: `b:helper` is `helper`. def local(+name: String) -> String: Common.is_package (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=is_package) # Whether a global name comes from a BendHub package (`0x/file:name`): not this project's code. def is_package(name: String) -> Bool: Common.has (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=has) # Whether a name is in a set. def has(s: Set(), name: String) -> Bool: Common.Edges.add.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Edges.add.of) # Graph of references between globals # ==================================== # Lists of names under a name, last added first. def Edges.add.of( got: Map<&2, List<&2, String>> & List<&2, String>, key: String, x: String ) -> Map<&2, List<&2, String>>: Common.Edges.add (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Edges.add) def Edges.add( m: Map<&2, List<&2, String>>, +key: String, x: String ) -> Map<&2, List<&2, String>>: Common.Edges.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Edges.of) # The names under `key`, last added first; the map is only read. def Edges.of(+m: Map<&2, List<&2, String>>, key: String) -> List<&2, String>: Common.Graph (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Graph) # What the facts say: the owners, `edges` (owner -> names it references, with repeats), and `into` # (name -> owners that reference it, with repeats). A name an owner uses for itself is no edge. type Graph is Data: Graph{owners: Owners, edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>>} Common.Graph.empty (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Graph.empty) def Graph.empty() -> Graph: Common.Graph.link (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Graph.link) def Graph.link( hit: Bool, +owner: String, +name: String, owners: Owners, edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>> ) -> Graph: Common.Graph.add.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Graph.add.of) def Graph.add.of( g: Graph, +owner: String, +inst: Bool, +kind: String, +name: String, span: Maybe<&2, Lint.Span> ) -> Graph: Common.base.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=base.of) def base.of(parts: List<&2, String>, name: String) -> String: Common.base (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=base) # A template call refers to an instance, `twice~0`, and a template's own parameter is `twice~f`: both # are the template, `twice`. def base(+name: String) -> String: Common.Graph.add (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Graph.add) def Graph.add(g: Graph, v: Lint.View) -> Graph: Common.Graph.collect (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Graph.collect) # A fold_facts step. def Graph.collect(g: Graph, +f: Lint.Fact) -> IO(Graph): Common.Laws.name (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.name) # Laws # ==== # Laws are specs, not code: a def that fills one is a proof. They are found in the text (`law name:` # at the start of a line), as the checker gives a law and its proof one owner and no flag. def Laws.name(parts: List<&2, String>) -> List<&2, String>: Common.Laws.line (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.line) def Laws.line(+line: String) -> List<&2, String>: Common.Laws.add (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.add) def Laws.add(names: List<&2, String>, out: Set()) -> Set(): Common.Laws.lines (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.lines) def Laws.lines(ls: List<&2, String>, out: Set()) -> Set(): Common.Laws.scan (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.scan) # The names of the laws written in the `sources` whose paths are in `paths`. def Laws.scan(read: Bool, text: String, out: Set()) -> Set(): Common.Laws.sources (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.sources) # A call evaluates its arguments, so a file is split into lines only through a match: Base is long. def Laws.sources(sources: List<&2, Lint.Source>, +paths: Set(), out: Set()) -> Set(): Common.Paths.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Paths.of) # The paths the owners' spans are in. def Paths.of(seen: List<&2, Seen>, out: Set()) -> Set(): Common.Laws.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.of) # The local names of every law in the program's own files. def Laws.of(sources: List<&2, Lint.Source>, owners: Owners) -> Set(): Common.Laws.has (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Laws.has) # Whether `owner` is a law or the proof that fills one. def Laws.has(laws: Set(), owner: String) -> Bool: Common.Bodies.put (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Bodies.put) # Owners that have a checked body # =============================== # Defs and laws have one; types and constructors do not. def Bodies.put(b: Maybe<&2, Lint.Node>, owner: String, out: Set()) -> Set(): Common.Bodies.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Bodies.of) def Bodies.of(seen: List<&2, Seen>, out: Set()) -> IO(Set()): Common.Entry.hit (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Entry.hit) # Entry lists: `a, b, prefix*` # ============================ # Whether the entry `e` names `name`: the same, or, if it ends in `*`, a prefix of it. def Entry.hit(+e: String, +name: String) -> Bool: Common.Entry.any (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Entry.any) # Whether some entry names `owner`, as written or without its namespace. def Entry.any(entries: List<&2, String>, +owner: String) -> Bool: Common.Entry.trim (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Entry.trim) def Entry.trim(xs: List<&2, String>) -> List<&2, String>: Common.Entry.parse (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Entry.parse) # A comma-separated option as a list. def Entry.parse(text: String) -> List<&2, String>: Common.Nodes.put (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Nodes.put) # The program's own code # ====================== # The defs of the program: owners with a checked body that are not laws, proofs or package code. def Nodes.put(hit: Bool, owner: String, out: Set()) -> Set(): Common.Nodes.is (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Nodes.is) def Nodes.is(+bodies: Set(), +laws: Set(), +owner: String) -> Bool: Common.Nodes.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Nodes.of) def Nodes.of(seen: List<&2, Seen>, +bodies: Set(), +laws: Set(), out: Set()) -> Set(): Common.Prog (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Prog) # Everything a graph rule reads: the owners in order, the reference maps, the set of defs, and the # local names of the laws. type Prog is Data: Prog{ seen: List<&2, Seen>, edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>>, nodes: Set(), laws: Set() } Common.Prog.with (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Prog.with) def Prog.with( +laws: Set(), +seen: List<&2, Seen>, edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>>, bodies: Set() ) -> Prog: Common.Prog.build (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Prog.build) def Prog.build( sources: List<&2, Lint.Source>, +seen: List<&2, Seen>, edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>>, bodies: Set() ) -> Prog: Common.Prog.owners (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Prog.owners) def Prog.owners( sources: List<&2, Lint.Source>, +seen: List<&2, Seen>, edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>> ) -> IO(Prog): Common.Prog.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Prog.of) def Prog.of(sources: List<&2, Lint.Source>, g: Graph) -> IO(Prog): Common.Count (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Count) # Degrees # ======= # A count of the different names that are defs, and the names counted. type Count is Data: Count{seen: Set(), n: U32} Common.Count.put (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Count.put) def Count.put(hit: Bool, +x: String, seen: Set(), n: U32) -> Count: Common.Count.add (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Count.add) def Count.add(is_def: Bool, +x: String, c: Count) -> Count: Common.Count.n (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Count.n) def Count.n(c: Count) -> U32: Common.distinct (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=distinct) def distinct(names: List<&2, String>, +nodes: Set(), c: Count) -> Count: Common.degree.go (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=degree.go) def degree.go(is_def: Bool, names: List<&2, String>, nodes: Set()) -> U32: Common.degree (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=degree) # The 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`). 0 for what is not a def. def degree(+m: Map<&2, List<&2, String>>, +nodes: Set(), +owner: String) -> U32: Common.Scope (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Scope) # Where 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. The `imports` option widens that to every file of the program. type Scope is Data: Scope{imports: Bool, root: String} Common.root_path (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=root_path) def root_path(sources: List<&2, Lint.Source>) -> String: Common.Scope.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Scope.of) def Scope.of(sources: List<&2, Lint.Source>, options: List<&2, Lint.Option>) -> Scope: Common.in_root (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=in_root) def in_root(+root: String, span: Maybe<&2, Lint.Span>) -> Bool: Common.Scope.has (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=Scope.has) def Scope.has(scope: Scope, span: Maybe<&2, Lint.Span>) -> Bool: Common.scoped.put (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=scoped.put) def scoped.put(hit: Bool, owner: String, span: Maybe<&2, Lint.Span>, out: List<&2, Seen>) -> List<&2, Seen>: Common.scoped (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/common.bend&name=scoped) # The owners a rule reports on. def scoped(+scope: Scope, seen: List<&2, Seen>) -> List<&2, Seen>: Cognitive.id (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=id) def id() -> String: Cognitive.facts (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=facts) def facts() -> Lint.Want: Cognitive.walk (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=walk) def walk(n: Lint.Node, depth: U32, chain: Bool, total: U32) -> IO(U32): Cognitive.walk.all (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=walk.all) # Each of `cs` the same way. def walk.all(cs: List<&2, Lint.Node>, +depth: U32, +chain: Bool, total: U32) -> IO(U32): Cognitive.walk.arms (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=walk.arms) # The children of a Mat: the first is an arm body, one level down; the others continue the chain. def walk.arms(cs: List<&2, Lint.Node>, +depth: U32, +first: Bool, total: U32) -> IO(U32): Cognitive.walk.step (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=walk.step) def walk.step( is_mat: Bool, is_ann: Bool, children: List<&2, Lint.Node>, +depth: U32, +chain: Bool, total: U32 ) -> IO(U32): Cognitive.walk.shape (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=walk.shape) def walk.shape(s: Lint.Shape, depth: U32, chain: Bool, total: U32) -> IO(U32): Cognitive.score.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=score.of) def score.of(body: Maybe<&2, Lint.Node>) -> IO(U32): Cognitive.message (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=message) def message(+name: String, score: U32, max: U32) -> String: Cognitive.judge (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=judge) def judge(+max: U32, seen: List<&2, Common.Seen>, out: List<&2, Lint.Diag>) -> IO(List<&2, Lint.Diag>): Cognitive.run (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=run) def run(input: Lint.Input) -> IO(List<&2, Lint.Diag>): Cognitive.main (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cognitive.bend&name=main) def main() -> IO(Unit): Cyclomatic.id (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=id) def id() -> String: Cyclomatic.facts (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=facts) def facts() -> Lint.Want: Cyclomatic.Tally (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=Tally) # Node kinds seen under a def. type Tally is Data: Tally{mats: U32, efqs: U32} Cyclomatic.bump.kind (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=bump.kind) def bump.kind(+kind: String, t: Tally) -> Tally: Cyclomatic.walk (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=walk) def walk(n: Lint.Node, t: Tally) -> IO(Tally): Cyclomatic.walk.all (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=walk.all) def walk.all(cs: List<&2, Lint.Node>, t: Tally) -> IO(Tally): Cyclomatic.walk.shape (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=walk.shape) def walk.shape(s: Lint.Shape, t: Tally) -> IO(Tally): Cyclomatic.complexity (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=complexity) # 1 + Mat - Efq; never below 1. def complexity(t: Tally) -> U32: Cyclomatic.score.of (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=score.of) def score.of(body: Maybe<&2, Lint.Node>) -> IO(U32): Cyclomatic.message (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=message) def message(+name: String, score: U32, max: U32) -> String: Cyclomatic.judge (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=judge) def judge(+max: U32, seen: List<&2, Common.Seen>, out: List<&2, Lint.Diag>) -> IO(List<&2, Lint.Diag>): Cyclomatic.run (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=run) def run(input: Lint.Input) -> IO(List<&2, Lint.Diag>): Cyclomatic.main (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/complexity/cyclomatic.bend&name=main) def main() -> IO(Unit): Def.id (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=id) def id() -> String: Def.facts (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=facts) def facts() -> Lint.Want: Def.is_root (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=is_root) # Entry points # ============ def is_root(+laws: Set(), +entries: List<&2, String>, +owner: String) -> Bool: Def.roots (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=roots) def roots( seen: List<&2, Common.Seen>, +laws: Set(), +entries: List<&2, String>, +out: List<&2, String> ) -> List<&2, String>: Def.reach (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=reach) def reach(work: List<&2, String>, +edges: Map<&2, List<&2, String>>, +seen: Set()) -> Set(): Def.reach.go (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=reach.go) def reach.go( known: Bool, +name: String, rest: List<&2, String>, +edges: Map<&2, List<&2, String>>, +seen: Set() ) -> Set(): Def.message (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=message) # Findings # ======== def message(+owner: String, referenced: Bool) -> String: Def.is_dead (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=is_dead) def is_dead(+nodes: Set(), +reached: Set(), +owner: String) -> Bool: Def.report (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=report) def report( seen: List<&2, Common.Seen>, +nodes: Set(), +reached: Set(), +into: Map<&2, List<&2, String>>, out: List<&2, Lint.Diag> ) -> List<&2, Lint.Diag>: Def.nothing (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=nothing) def nothing() -> Lint.Diag: Def.verdict.go (https://jend.leeeet.dev/definition.txt?path=bend-lint-pack@0.1.1.0/dead/def.bend&name=verdict.go) # `none`: there is no entry point. `shown`: the owners reported on. def verdict.go( none: Bool, +rs: List<&2, String>, shown: List<&2, Common.Seen>, nodes: Set(), +edges: Map<&2, List<&2, String>>, into: Map<&2, List<&2, String>> ) -> List<&2, Lint.Diag>: More: https://jend.leeeet.dev/packages/bend-lint-pack.txt?definitions_offset=100