bend-lint-rules

Search uses release 0.2.0.0 · 801 definitions

Releases (5)

Definitions (801)

performance/deep_call_in_fork.bend

def deepThe definitions among `nodes` that call themselves outside a tail position, as the check names them, onto `out`; with `forking` false, not those with a parallel let, whose such calls are the values of their forks.
def is_pattern
def binders
def leadsWhether a let leads to a fork: it is one (it binds `many` names), or it binds one (`one`), and the last of `nodes`, the rest of its block, is a let that leads to one.
def is_valueWhether `x`, the node at `at` under `parent`, is a value of a fork, or of a let just before one: not a binder, nor the rest of the block.
def is_insideWhether `x`, below `path`, or a node above it, is a value of a fork, or `found`.
def message
def judge.deepThe finding about a call of a deep definition (if `deep`), when the call is in a fork.
def judge.call
def visit
def defs
def run
def rule

performance/drop_in_bang.bend

type ProgramWhat judging a file's calls reads: the program's definitions, by the name the check gives them, and where the file writes `!(`.
def messageFunctions =========
def visitThe finding about an application below `path`, if it is a `!` call that only frees.
def run
def rule

performance/eager_branch.bend

type EagerA value Bend computes whether needed or not: what computes it ("pick", "&&" or "||"), and the value.
type OwnerWhat judging the calls in one definition reads: the definitions of the program a call of which runs a loop to its end (see costly), and the definition, as the check names them.
def eagerFunctions ========= What an application with the nodes `kids` computes whether needed or not, as its node at `at` is one of its arguments: "pick" for a value of Bool.pick, "&&" or "||" for their right side, "" for none.
def Eager.of
def eagerlyThe eager value a call below `path` is in, if one is above it and no lambda comes between.
def why
def message
def judged
def looping
def visit
def defs
def templatesThe binders of the `~` parameters among a definition's nodes, onto `out`: a call of one is inlined, not a closure's.
def applies.visitA closure's application: of a variable that no `~` parameter (`templates`) binds.
def appliesWhether a definition's nodes apply a closure, or `found`.
def unflatThe definitions among a file's `nodes` whose own body keeps them from compiling to a native loop, onto `out`: a parallel let is in them, or a closure's application.
def program.unflatThe definitions of the program whose own body keeps them from compiling to a native loop, onto `out`: those of `unflat`, and those that call themselves outside a tail position.
def calls_itself
def loopsThe definitions among `names` that call themselves and are in `unflat`, onto `out`.
def costlyThe definitions of the program a call of which runs a loop to its end, even when its value is unused: a loop that does not compile to a native loop, as its body, or one it calls, keeps it from that (see program.unflat); or a definition that calls such a loop.
def run
def rule

performance/gpu_fit.bend

type SlotA field of a datatype: the datatype, and the field's type as one name ("" if it is not one name).
type ProgramWhat judging a file's calls reads: the program's definitions, by the name the check gives them; those under which a parallel let runs (see program.under); the fields of its datatypes; and where the file writes `!(`.
def slotsThe fields of the datatypes among `nodes` and under them (of `current`, the datatype they are under), onto `out`.
def is_dropWhether a call of `t` (`info`, if the program defines it) only frees its inputs: it returns Unit, as Base's Image.drop, Image.free and Image.sink do.
def program.slots
def is_scalar
def fields
def is_known
def is_flat.expand
def is_flat.nextWhat is left to check after `t`: its fields, if it is a datatype; nothing more, if it is a number; none (data), else.
def is_flatWhether the types of `todo` are numbers, or records of numbers.
def dataThe first parameter of `params` that is data, if one is.
def forkingThe definitions among `names` that a parallel let is in, onto `out`.
def program.underThe definitions under which a parallel let runs: in them, or under what they call.
def bangsWhere `text` writes `!(`, from offset `at`: the end of each bang's name.
def alone
def slower
def faster
def Def.target
def unbangedThe finding about a call of `info` without `!`, if it forks over numbers only and the caller does not fork.
def banged.ofThe finding about a `!` call: of a definition under which no parallel let runs (`forks` is false), or of one that forks and receives data (`param`).
def bangedThe finding about a `!` call of a definition of the program (`info`), unless the call only frees (`drop`): performance/drop_in_bang reports that.
def judged
def visitThe finding about an application below `path`, if its function is a definition of the program.
def run
def rule

performance/list_index_loop.bend

type WalkerA function that walks a list from its head (named as the check names it): which argument is the list, and the Base function that walks it.
type LoopWhat judging the calls in one definition reads: the walkers of the file, and the definition.
def basesFunctions =========
def binderThe binder of the variable `node` uses, if it is a variable.
def Walker.at
def Walker.helped
def Walker.helperThe walker `owner` is, if a call in it of a Base walker (`base`, with `args`) walks one of its parameters.
def Walker.visit
def Walker.helpersThe definitions among `nodes` that give a parameter to a Base walker, as walkers, onto `out`.
def is_passedWhether a variable of the binder `b` is among `args`, or `found`.
def is_passed.ifWhether `args`, the arguments of a call of `target` (if `called`), pass the binder `b` unchanged.
def passesWhether a call of `target` among `nodes`, or under them, passes the binder `b` unchanged, or `found`.
def innermostThe innermost case above `path`, if any: a call of the loop must be in it to pass the list on in the same branch.
def advice
def message
def loopsWhether the loop `owner`, if a parameter of it declares the binder `b` (`param`), passes it unchanged to a call of itself (`target`), in the innermost case above `path`.
def feedsWhether the call below `path` is an argument of a call of `target`, the loop itself.
def judged.listThe finding about a walker's call, below `path`, of the list `list` with the binder `walked` that the loop `owner` passes unchanged to a call of itself in the same branch.
def judgedThe finding about a call of the walker `walker`, with `args`.
def call
def visit
def defs
def run
def rule

performance/loop_invariant_call.bend

type OwnerWhat judging the calls of one definition reads: the definitions of the file that call themselves (as the check names them), the definition (as the check names it, and as written), and its parameters that it passes unchanged to each call of itself, by binder.
def messageFunctions =========
def loop.visit
def loopsThe definitions among `nodes` that call themselves, as the check names them, onto `out`.
def self.visitThe arguments of each call of the definition below `path` to itself.
def passed.at
def passedWhether the argument at `at` of each of `calls` is the variable of `b`.
def fixedThe runtime parameters among a definition's nodes that it passes unchanged to each of `calls` (its calls of itself), by binder; `at` counts the runtime parameters, as the calls' arguments do.
def Owner.ofWhat judging the calls of the definition `node` reads, with `loops`, the definitions of the file that call themselves.
def invariantWhether `nodes`, the arguments of a call, are the same on every step: literals, the variables of `fixed`, and calls, annotations or constructions of those alone; `fuel` bounds the depth.
def has_callWhether a call of `target` is among `nodes` or under them, or `found`.