Diagnostic Index

Every diagnostic the checker can report, and the section that shows what causes it.

Code	Shown in
abstract-requires-extensible	struct — Marking a struct abstract without extensible
abstract-struct-instantiation	struct — Constructing an abstract struct
ambiguous-inferred-type	array — An empty literal with no element type optional — An absent value with no type to be absent of block-let-assert — An initializer with no type of its own literals — A numeric literal nothing pins
annotation-arg-count	annotation — The wrong number of arguments
annotation-arg-type	annotation — An argument the parameter's type does not accept
annotation-scope-mismatch	annotation — Applying an annotation outside its scopes
array-index-type	array — An index that is not an integer
assert-condition-type	struct — An assertion whose condition is not bit block-let-assert — An assertion whose condition is not bit contract — An assert condition that is not bit
branch-else-not-last	branch — An else arm that is not last
branch-guard-type	branch — A guard that is not bit
break-outside-loop	positions — A break with no enclosing loop loop — A break naming a loop that does not enclose it loop — A break outside every loop
builtin-call-args	optional — A fallback that is not the inner type builtin-functions — An argument of the wrong type builtin-functions — Serializing a width that is not a whole number of bytes builtin-functions — Serializing something with no byte width builtin-functions — The wrong number of arguments
call-arg-count	variant — Applying a constructor with the wrong number of arguments function — Calling with the wrong number of arguments
call-arg-type	variant — A payload argument of the wrong type function — An argument of the wrong type
choice-component-not-component	choice — Deciding in something that is not a component
comprehension-filter-type	comprehension — A filter that is not bit
comprehension-zip-filter-exclusive	comprehension — zip together with a filter
comprehension-zip-scan-exclusive	comprehension — zip together with scan
connection-clause-target	connection — A clause part that names the wrong kind of declaration
connection-directionality	connection — A clause that runs against the connection it names connection — A statement that names another component in its own role listen — An arm receiving from the wrong end
connection-target-not-component	connection — An endpoint that is not a component group — Using a group where a component is required
const-self-reference	const — A const that references itself
context-param-duplicate-type	transform — Two contextual parameters of one type
context-param-ref-scope	transform — A contextual reference outside a transform
cyclic-const	const — Consts that reference each other
cyclic-group-membership	group — A group that contains itself
cyclic-inheritance	struct — Inheritance that forms a cycle
cyclic-type-alias	type-alias — An alias defined in terms of itself
do-component-mismatch	do — Calling a protocol that runs on another component
do-tail-position	do — A do tail with something after it
duplicate-annotation-param	annotation — Two parameters with one name
duplicate-contract-param	contract — Declaring the same parameter twice
duplicate-declaration-name	module — Two declarations with one name component — Declaring the same component twice
duplicate-enum-member	enum — Two members with one name
duplicate-field-binding	literals — A field bound twice
duplicate-field-name	struct — Declaring the same field twice
duplicate-group-membership	group — A component in two groups group — The same member twice in one group
duplicate-import-element	import — The same element twice in one import
duplicate-in-block-binding	in-block — One name in two in blocks
duplicate-module	module — Two files naming the same module
duplicate-param	function — Declaring the same parameter twice
duplicate-unique-annotation	annotation — The same Unique values twice in one package
duplicate-variant-constructor	variant — Two constructors with one name
empty-enum	enum — An enum with no members
empty-variant	variant — A variant with no constructors
enum-backing-type-mismatch	enum — A member value the backing type does not accept
exch-from-to-required	exch — An exchange that fixes only one endpoint
exch-into-target-not-var	exch — An into target that is not a binding
exch-type-mismatch	exch — Two halves that disagree about the message
extends-non-extensible	struct — Extending a struct that is not extensible
extends-non-struct	struct — Extending something that is not a struct
filter-body-type	fold-map-filter-flatmap — A filter body that is not bit
filter-source-type	fold-map-filter-flatmap — A filter over something that is neither an array nor an optional
flatmap-body-type	fold-map-filter-flatmap — A flatmap body that is not a collection
flatmap-source-type	fold-map-filter-flatmap — A flatmap over something that is neither an array nor an optional
fold-body-type	fold-map-filter-flatmap — A fold body that is not the accumulator's type
fold-init-type	fold-map-filter-flatmap — A fold initializer of the wrong type
fold-source-type	fold-map-filter-flatmap — A fold over something that is not an array
giving-arg-count	transform — The wrong number of contextual arguments
giving-arg-type	transform — A contextual argument of the wrong type
giving-required	transform — A contextual transform called with no context available
giving-target	transform — giving on a call that takes no context
group-member-target	group — A member that is not a component or a group
illegal-shadowing	block-let-assert — Binding a name that is already in scope
import-conflict	import — An imported name this file already declares import — The same element twice in one import
in-block-component-not-component	in-block — An in block for something that is not a component
incompatible-branch-types	array — Elements of more than one type if — Branches of two different numeric widths if — Branches with no common type match — Arms whose bodies have different types
incompatible-pattern	variant — A pattern that binds the wrong number of payloads match — A pattern the discriminee's type cannot match
inherited-field-collision	struct — Redeclaring an inherited field
invalid-annotation-scope	annotation — A scope the language does not define
invalid-member-access	tuple — An element index the tuple does not have literals — A field the struct does not declare
invalid-operand-types	array — Concatenating arrays of different element types operators — Operands the operator does not accept
local-protocol-component-not-component	local-protocol — Running a protocol in something that is not a component
loop-invariant-expression	loop — An invariant that does not begin with a bound variable
map-source-type	fold-map-filter-flatmap — A map over something that is neither an array nor an optional
message-data-type	listen — An arm receiving a type that has no wire form recv — Receiving into a variable that has no wire form send — Sending a type that has no wire form
missing-field	literals — A field left unbound
newtype-field-count	—
newtype-value-syntax	newtype — Field bindings in place of a value
newtype-value-type	newtype — A wrapped value of the wrong type
non-exhaustive-match	match — A discriminee the arms do not cover
not-a-struct-or-newtype	newtype — A literal whose target is neither a struct nor a newtype
not-a-type	const — Naming a const where a type is expected type-alias — An alias naming something that is not a type
not-an-annotation	annotation — Using something that is not an annotation
recv-assumption-type	recv — An assuming predicate that is not bit
reserved-builtin-name	builtin-functions — Taking a built-in name for a declaration
send-predicate-type	send — A where predicate that is not bit
set-target-not-var	local-protocol — Reassigning a let binding
sync-choice-guard	choice — A synchronized guard naming something other than a synchronized variable choice — A synchronized guard that is not a condition
system-duplicate-component	system — Two protocols on the same component
system-protocol-not-local	system — Listing something that is not a local protocol
transform-min-params	transform — A transform with no parameters
transform-param-type	transform — A parameter that is not a message struct
transform-return-type	transform — A return type that is not a message struct
tuple-pattern-arity	tuple — A pattern that binds the wrong number of elements block-let-assert — A tuple pattern of the wrong length
type-mismatch	const — An initializer that does not match the declared type enum — Using an enum value as its backing type newtype — The underlying type in place of the newtype optional — A payload of the wrong type optional — An optional where the inner type is expected primitives — A value of another primitive type tuple — A tuple of a different arity if — A condition that is not bit try — Using the result where the plain value is expected function — A body that is not the return type fold-map-filter-flatmap — A flatmap body that is not a collection
unresolved-reference	struct — Naming an inherited field in an assertion block-let-assert — Naming a binding outside the block that made it transform — A contextual reference outside a transform import — Importing a contract import — Importing a module the project does not hold import — Naming an element the module does not declare choice — A guard naming another component's state component — Naming a component that was never declared in-block — Reading a binding from a component that is not involved
value-cast-source-type	value-cast — A source that is not numeric
value-cast-target-type	value-cast — A float64 narrowed to a float32 value-cast — A target that is not numeric
value-cast-widening	value-cast — A float64 narrowed to a float32 value-cast — A narrowing conversion asked for infallibly