bend-lint-rules

Search uses release 0.2.0.0 · 801 definitions

Releases (5)

Definitions (801)

layout/imports.bend

def judgedThe block as written (`written`, at `span`), against its imports in order, each file once.
def judge
def run
def rule

lib/linter/directives.bend

type CommentA comment: where it is (code points), its line (from 0), whether code comes before it on its line, and its text after the #.
type Glyph
type ModeWhere the scan is: in code, a comment, or a string or char literal (`string`), maybe just after a \ in it.
type ScanThe scan so far: where it is, its offset and line, whether its line holds code, the comment it is in (its body last first), the comments before (last first), and whether each line before holds code (last first).
type Scanned
def Glyph.of
def Comment.noneNo comment: what the scan holds as its open comment outside one.
def Comment.closedThe comment `open`, ended at `at`, its body in order.
def Comment.push
def Scan.in_code
def Scan.in_comment
def Scan.quoteWhere a quote leaves the scan: a string's " and a char's ' close it; the other quote does not.
def Scan.in_quoteA step in a string or a char literal (`string`): a \ escapes the next character, its closing quote ends it, and a line it spans holds code.
def Scan.step
def Scan.go
def Scan.done
def Scan.of
type ActionParsing =======
type Scope
type Keyword
type TargetWhat a directive names: a rule, and the severity it pins, as written.
type DraftA directive as written, before its severity and rule are checked: its reasons are the texts after each `--`.
type DirectiveA directive: what it does, how far, the rule it names, the severity it pins, its comment, and its place among the file's comments.
type SaidA comment that says bend-lint: a directive, or what is wrong with it.
def Action.show
def Scope.show
def Action.names
def Scope.names
def Severity.pinned
def Severity.is_eq
type WordsThe words of a text, split at blanks: the word so far, last first, and the words before it, last first.
def Words.step
def Words.go
def Words.done
def Words.of
def Draft.kind
def Draft.is_rule_idWhether a rule id is one or more non-empty parts, split by /: its path in bend-lint-rules/.
def Draft.target`rule@severity`, split at its @s.
def Draft.labelThe word that starts a disable's second reason: why it is not an expect.
def Draft.part
def Draft.reasons.stepThe reason so far (last first) and those before it (last first), with `word` read: the label starts another.
def Draft.reasonsThe reasons in `words`, split at each label, in order, after what is `read`.
def Draft.reasonWhat comes after the rule: nothing, or `--` and the reasons.
def Draft.ofThe draft of a directive's words, after `bend-lint:`.
def Problem.pinned
def Problem.severity
def Problem.reason
def Problem.because
def Problem.line
def Problem.first
def Rule.is_reserved
def Said.checked
def Said.ofWhat a comment that holds `draft` (or not) says, checked against the rules there are.
def Draft.read.if
def Draft.readWhat a comment's text says, if it says bend-lint:: a directive's draft, if it is one.
def Said.read.of
def Said.read
def Said.allWhat the comments say, in order, each numbered; `out` holds those so far, last first.
type ClosedWhere a begin was closed: its index, and the line of its end.
type PairingThe begins open so far (latest first), the begins closed, and what is wrong (last first).
def Open.latestThe latest open begin of an action and a rule.
def Open.keep
def Open.without
def Pairing.closing
def Pairing.close
def Pairing.step
def Pairing.go
def Pairing.unclosed
type CoveringA directive and the lines it covers, both ends included (from 1 to 0 covers none).
def Lines.next_codeThe first line after `after` that holds code; `i` is the line of the head of `lines`.
def Closed.find
def Covering.next
def Covering.ofThe lines a directive covers; `last` is the file's last line.
def Covering.all
def Covering.pins
def Covering.coversWhether a covering covers a finding of `rule` and `severity` on line `row`.
def Covering.hit
def Covering.hits
type AppliedThe findings so far: those that stay, those a directive covers (both last first), and the directives that covered one.
type SuppressedA file's findings after its directives: those that stay, then the findings about its directives, and those a directive covers.
def Applied.add
def Applied.goThe findings, each with where it starts (`at`, in order), sorted by the directives that cover their lines.
def Unmet.add
def Unmet.goThe findings about the directives that nothing used: an expect not met, a disable that covered nothing.
def Wrong.found
def Found.offsetsWhere each of `founds` starts, in order, onto `out` (last first).
type LintedA linted file: its path and text, the ids of the rules there are, and those of the rules that ran on it.
def Linted.path
def Linted.text
def Linted.known
def Linted.ran
def Covering.keep
def Covering.ran
def done
def covered
def paired