Silk diagnostic index
Every diagnostic code the Silk compiler can report, with its meaning.
Each code is stable: it identifies one condition and never changes meaning between releases. The prefix names the compiler phase that reports it. Regenerate this page with:
$ pnpm --filter @silklang/compiler documentation:generate| Prefix | Phase | Codes |
|---|---|---|
LEX | Lexical | 12 |
PAR | Parser | 5 |
MOD | Module | 2 |
SEM | Semantic | 202 |
OWN | Ownership | 19 |
LAY | Layout | 1 |
There are 241 codes in total.
Lexical (LEX)
| Code | Meaning | Reported as |
|---|---|---|
LEX0001 | Stable diagnostic code for a maximal unsupported byte region. | Unsupported byte sequence |
LEX0002 | Stable code for an identifier-like modifier outside the closed literal vocabulary. | Unknown static-literal modifier: <modifier> |
LEX0003 | Stable code for a literal whose matching closing delimiter is absent. | Unterminated <subject> literal |
LEX0004 | Stable code for an integer-literal base prefix that no digit follows. | Base-<radix> integer literal without digits |
LEX0005 | Stable code for a number-literal digit separator outside a position between two digits. | Digit separator must sit between two digits |
LEX0006 | Stable code for a float-literal exponent marker that no exponent digit follows. | Float literal exponent must have at least one digit |
LEX0007 | Stable code for a character literal that denotes a number of scalars other than one. | Character literal must hold exactly one Unicode scalar, but holds <scalars> |
LEX0008 | Stable code for a duration component amount that is not a whole decimal integer. | Duration components require whole decimal amounts |
LEX0009 | Stable code for an identifier-like suffix outside the duration unit vocabulary. | Unknown duration unit <spelling> |
LEX0010 | Stable code for a duration unit repeated within one compact literal. | Duration unit <unit> may appear only once |
LEX0011 | Stable code for duration components that do not descend from larger to smaller units. | Duration unit <unit> must not follow <previous> |
LEX0012 | Stable code for a subordinate duration component outside its canonical field bound. | Subordinate <unit> component <amount> exceeds <maximum> |
Parser (PAR)
| Code | Meaning | Reported as |
|---|---|---|
PAR0001 | Stable code for one required token that is absent at its insertion position. | Expected <describeexpected> |
PAR0002 | Stable code for one maximal region of unexpected concrete tokens. | Unexpected <encountered>; expected valid syntaxUnexpected <encountered>; expected <expectation>Unexpected <encountered> while parsing a statementUnexpected <encountered> while parsing a <context> |
PAR0003 | Stable code for a primary-expression template start reserved for future support. | Template syntax is reserved but not implemented |
PAR0004 | Stable code for an import whose reserved final path segment cannot form an implicit binding. | Reserved module segment <spelling> requires an explicit alias or selected-member list |
PAR0005 | Stable code for an expression child beyond the parser's supported nesting depth. | Expression nesting exceeds the supported limit of <limit> |
Module (MOD)
| Code | Meaning | Reported as |
|---|---|---|
MOD0001 | Stable code for an import naming a module absent from the supplied sources. | Unknown module <module> |
MOD0002 | Stable code for an import redundantly naming its own containing module. | Module <module> imports itself |
Semantic (SEM)
| Code | Meaning | Reported as |
|---|---|---|
SEM0001 | Stable code for a present return-type name that is not a bootstrap built-in. | Unknown type <spelling> |
SEM0002 | Stable code for a literal outside its selected integer range. | Integer literal <spelling> exceeds the <type> range <minimum> through <maximum> |
SEM0003 | Stable code for a present declaration name repeated after its first occurrence. | Duplicate declaration name <spelling> |
SEM0004 | Stable code for a present call name with no matching top-level declaration. | Unknown function <spelling> |
SEM0005 | Stable code for a present parameter name repeated after its first occurrence. | Duplicate parameter name <spelling> |
SEM0006 | Stable code for a present value name with no matching local declaration. | Unknown value <spelling> |
SEM0007 | Stable code for a uniquely resolved call with the wrong number of arguments. | Expected <expectedCount> <expectedCount1argumentarguments> but received <actualCount> |
SEM0008 | Stable code for a binding whose name repeats a parameter or an earlier binding. | Cannot rebind <spelling> |
SEM0009 | Stable code for a qualified call naming an unknown built-in actor. | Unknown actor <spelling> |
SEM0010 | Stable code for a known actor called with an unknown operation name. | <actor> has no operation <spelling> |
SEM0011 | Stable code for a conditional whose condition is not bool. | Condition must be bool, found <actual> |
SEM0012 | Stable code for a call argument whose type mismatches its parameter. | Expected <expected> but received <actual> |
SEM0014 | Module <module> has no member <spelling> | |
SEM0015 | <module>.<spelling> is private | |
SEM0016 | Multiple bindings claim <spelling> | |
SEM0017 | Duplicate field name <spelling> | |
SEM0018 | Expected a type, found <spelling> | |
SEM0019 | Public declaration exposes private type <type> | |
SEM0020 | Inline recursive aggregate layout: <join> | |
SEM0021 | Cannot construct <type> because its raw constructor is not available at this site | |
SEM0022 | <type> has no field <field> | |
SEM0023 | Field <field> is initialized more than once | |
SEM0024 | Missing initializer for <type>.<field> | |
SEM0025 | Field <field> expects <expected> but received <actual> | |
SEM0026 | Cannot project a field from <actual> | |
SEM0027 | <type> has no field <field> | |
SEM0028 | <type>.<field> is private | |
SEM0029 | An empty array literal needs an expected Array type | |
SEM0030 | Array element <index> expects <expected> but received <actual> | |
SEM0031 | Array literal expects <expected> elements but received <actual> | |
SEM0032 | Cannot index <actual> | |
SEM0033 | Array index must be usize, found <actual> | |
SEM0034 | Array index <index> is outside length <length> | |
SEM0035 | Cannot assign through immutable binding <spelling> | |
SEM0036 | Assignment requires a writable binding, field, or indexed place | |
SEM0037 | Assignment expected <expected> but received <actual> | |
SEM0038 | <transfer> is only valid inside a loop | |
SEM0039 | Structural union members must be detached ordinary values with finite storage, found <type> | |
SEM0040 | <source> cannot widen to <target>; missing <join> | |
SEM0041 | Cannot match non-nominal type <actual> | |
SEM0042 | <member> is not a member of <scrutinee> | |
SEM0043 | Unreachable match arm <member> | |
SEM0044 | Match does not cover <join> | |
SEM0045 | Match guard must be bool, found <actual> | |
SEM0046 | Pattern for <type> is missing field <field>; add it or use .. | |
SEM0047 | Pattern field <field> appears more than once | |
SEM0048 | Pattern binding <spelling> conflicts with an existing declaration | |
SEM0049 | Match arms have incompatible result types: <join> | |
SEM0050 | Duplicate type parameter <spelling> | |
SEM0051 | <target> expects <expected> type argument<expected1s>, received <actual> | |
SEM0052 | Cannot infer all type arguments for <target> from supplied values | |
SEM0053 | Recursive specialization changes type arguments from <caller> to <target> | |
SEM0056 | Stable code for an operand that cannot form a borrowed view. | A borrowed view requires a direct stable owner or borrowed view |
SEM0057 | Exclusive borrowing requires mutable binding <spelling> | |
SEM0058 | A shared slice cannot be reborrowed exclusively | |
SEM0059 | Passing an array as <expected> requires an explicit borrow | |
SEM0060 | Stable code for a negative decimal literal contextualized as unsigned usize. | usize literals cannot be negative |
SEM0061 | Stable code for a type that cannot inhabit an Effect failure channel. | Effect failure <type> must be a detached ordinary value type |
SEM0062 | Stable code for a failure channel attached to an ordinary function. | Only effect functions may declare a failure channel |
SEM0063 | Only effect functions may originate a typed failure | |
SEM0064 | Failure <type> is not declared by this effect function | |
SEM0065 | Cannot run non-effect value <type> | |
SEM0066 | Run leaves unhandled failures: <join> | |
SEM0067 | Invalid Effect.catch handler: <detail> | |
SEM0068 | Effect recipe bindings are immutable | |
SEM0070 | Stable code for a non-concrete or non-nominal capability in a requirement row. | Effect requirement <type> must be one concrete service type |
SEM0071 | Run leaves unsatisfied requirements: <join> | |
SEM0074 | Invalid Effect provider: <detail> | |
SEM0075 | Cannot call non-callable value <actual> | |
SEM0076 | Callable <actual> cannot satisfy <expected> | |
SEM0077 | Callable invocation requires <toLowerCase> access | |
SEM0078 | <target> is unary; name it directly instead of calling it with no arguments | |
SEM0080 | Cannot merge callable values from different construction sites without explicit erasure | |
SEM0081 | Cannot return an owned callable whose concrete environment identity is unknown | |
SEM0082 | Stable code for a raw storage operation outside lexical unsafe authority. | <operation> requires unsafe acknowledgement |
SEM0083 | Stable code for an invalid source-declared capability implementation. | Invalid conformance: <detail> |
SEM0084 | Stable code for a Drop implementation outside the compiler-sealed hook contract. | Invalid Drop hook: <detail> |
SEM0085 | Stable code for malformed escapes, invalid UTF-8, or non-byte literal values. | Invalid static literal: <detail> |
SEM0086 | Stable code for a typed constant whose type or literal is outside the constant contract. | Invalid constant: <detail> |
SEM0087 | Stable code for an expression statement whose result cannot be intentionally ignored. | Expression statement produces <actual>, but only () or never may be ignored |
SEM0088 | Stable code for using a generic binder in a value, failure-row, or requirement-row position of another kind. | Generic parameter <spelling> has kind <actual>, expected <expected> |
SEM0089 | Stable code for a failure or requirement row that cannot be finitely decomposed. | Failure type does not contain selected member <member>Requirement row does not contain &mut <capability>@<role>Requirement row does not contain &<capability>@<role>Requirement <capability> has role <joinor>, expected <expected>Requirement <capability>@<role> has access <joinor>, expected <expected>Requirement row remainder is ambiguous across <join>Requirement row specialization is not finite and concrete |
SEM0090 | Stable code for storage, bodies, or defaults inside a source service contract. | Invalid service declaration: <detail> |
SEM0093 | Stable code for one reachable intrinsic unavailable on the requested execution target. | <operation> is unavailable for <target> |
SEM0095 | Stable code for a float literal spelling no floating-point value can represent. | Invalid float literal: <spelling> |
SEM0097 | Stable code for a bound operation call whose receiver names more than one bounded parameter. | <spelling> is ambiguous across bounded type parameters <join> |
SEM0099 | Stable code for one named type parameter left undetermined by an explicit prefix and the arguments. | Cannot infer type argument <parameter> of <target> from supplied values |
SEM0100 | Stable code for an explicit type argument contradicting the type its value arguments imply. | Type argument <parameter> of <target> is <written>, but the supplied values imply <implied> |
SEM0101 | Stable code for a bound operation whose selected witness has no lowering. | <spelling> has no witness that can be lowered for <provider> |
SEM0103 | Stable code for constructing an aggregate that stores a bare callable value. | Cannot construct <aggregate>: <site> retains the static identity of <callable>, but represented callable storage has no supported runtime layoutCannot construct <aggregate>: <site> would store the <kind> <callable>, whose environment layout depends on a hidden concrete identity that <aggregate> does not carry |
SEM0104 | Stable code for the first struct initializer that contradicts an inferred representation. | Representation <parameter> was inferred as <expected>, but this initializer uses <actual> |
SEM0105 | Stable code for the first exact representation that diverges at a static value join. | Cannot join <expected> with <actual>; consume each represented value inside its branch before joining |
SEM0106 | Stable code for a representation argument whose contract cannot satisfy its required bound. | Representation <parameter> requires <required>, but the supplied bound <actual> is not admissible |
SEM0107 | Stable code for storing a represented Effect before its runtime layout is supported. | Cannot construct <aggregate>: <site> retains the static identity of <effect>, but represented Effect storage has no supported runtime layout |
SEM0108 | Stable code for a typeof item that resolves to no declaration in scope. | Cannot name the exact representation of <item>: no declaration of that name is in scope |
SEM0109 | Stable code for a typeof item whose name belongs to more than one declaration. | Cannot name the exact representation of <item>: <count> declarations carry that name, so no single item is resolved |
SEM0110 | Stable code for a typeof item that names something other than an ordinary callable. | Cannot name the exact representation of <item>: it names <subject>, which has no source-nameable exact identity |
SEM0111 | Stable code for a typeof item whose generic parameters are not all supplied. | Cannot name the exact representation of <item>: an exact representation names one construction, but <expected> generic parameters were declared and <actual> concrete arguments were supplied |
SEM0112 | Stable code for a public contract exposing the exact identity of a private item. | Public contract exposes the exact representation of private <item> |
SEM0113 | Stable code for one opaque producer specialization yielding multiple exact identities. | Opaque result <family> has divergent reachable realizations: <join> |
SEM0114 | Stable code for an opaque family whose representation evidence contains no local construction. | Opaque realization cycle has no local concrete construction: <join> |
SEM0115 | Stable code for an opaque realization whose inline captures contain that same family. | Opaque results form an infinite inline layout cycle: <join> |
SEM0116 | Stable code for an opaque result binder whose bound is not callable or Effect representation. | Opaque result binder <binder> must have a callable or Effect representation bound, but its kind is <actual> |
SEM0117 | Stable code for an opaque producer whose reachable returns establish no representation. | Opaque result <family> has no reachable callable or Effect representation construction |
SEM0118 | Stable code for an opaque result declared where no producer body can establish its identity. | Opaque result <declaration> is not permitted on a <context> operation because no producer body can establish one static representation |
SEM0119 | Stable code for two conformance heads that may name one provider under one interface. | <head> may overlap <other> |
SEM0120 | Stable code for a conformance requirement that does not descend toward a base witness. | <head> declares a requirement that does not descend |
SEM0121 | Stable code for a concrete specialization whose conditional requirements cannot be proved. | <goal> cannot be proved: <detail> |
SEM0122 | Stable code for a complete application that reaches the instance frontier with open rows or evidence. | <declaration> reaches a complete application with unresolved contract rows or evidence |
SEM0123 | Stable code for a provider that matches no member of its concrete source requirement row. | The provider matches no compatible requirement |
SEM0124 | Stable code for provider relations sharing a selector but retaining disjoint candidate sets. | Provider constraints select incompatible requirement members |
SEM0125 | Stable code for provider selection that retains more than one common requirement member. | The provider matches more than one requirement; select one explicitly |
SEM0126 | Stable code for an explicitly or independently selected row that is not exactly one member. | Selected requirement row has <count> members; exactly one is required |
SEM0127 | Stable code for a surviving provider candidate with more than one conformance witness. | More than one conformance witness can provide the selected requirement |
SEM0128 | Stable code for a surviving provider candidate whose conformance mapping is invalid. | The provider's conformance mapping is invalid: <reason> |
SEM0129 | Stable code for an explicit return whose value violates the declaration result. | Return expected <expected> but received <actual> |
SEM0130 | Stable code for a reachable non-unit function fallthrough. | A reachable path must return <expected> |
SEM0131 | Stable code for a provider whose key matches but whose access cannot satisfy the requirement. | <toLowerCase> provider access cannot satisfy an <toLowerCase> requirement |
SEM0132 | Stable code for an Effect join whose alternatives cannot be represented as a finite composite. | Cannot form a finite Effect join: <detail> |
SEM0133 | Stable code for a refutable pattern in an unconditional local binding. | Let pattern is refutable for <actual>; it does not cover <join>. Use if let or match |
SEM0134 | Stable code for an operator marker that cannot describe its interface operation. | Invalid operator contract: <detail> |
SEM0135 | Stable code for operator syntax with no marked operation accepting its operands. | Operator <operator> does not accept (<join>) |
SEM0136 | Stable code for operator syntax matched by more than one marked operation. | Operator <operator> is ambiguous between <join> |
SEM0137 | Stable code for an unsafe acknowledgement that does not complete an unsafe invocation. | `unsafe` must acknowledge a complete unsafe invocation |
SEM0138 | Stable code for a statically known allocation/layout specialization mismatch. | Local-shared allocation was planned for <actual>, not <expected> |
SEM0139 | Stable code for a concrete executable that fails one sealed static-property obligation. | <property> is unsatisfied: <join> |
SEM0141 | Stable code for an ordinary capability conjoined with one exact executable bound. | <conjunct> is not a sealed executable property |
SEM0142 | Stable code for a statically known execution-package allocation/layout mismatch. | Execution allocation was planned for <actual>, not <expected> |
SEM0143 | Stable code for mut where no mutable owned parameter storage exists. | `mut` declares function-local owned parameter storage and is not valid in a service or interface contract`mut` declares mutable owned parameter storage; use `&mut` for exclusive borrowed access |
SEM0145 | Stable code for mutating an outer callable from a deferred effect recipe. | A deferred effect cannot mutate captured callable binding <spelling> |
SEM0146 | Stable code for a scalar enum with no declared members. | Enum <enumName> must declare at least one member |
SEM0147 | Stable code for a scalar enum representation outside the fixed-width integer set. | <spelling> is not a scalar enum representation |
SEM0148 | Stable code for a scalar enum member name repeated after its first declaration. | Duplicate enum member name <spelling> |
SEM0149 | Stable code for a scalar enum discriminant repeated after its first declaration. | Duplicate enum discriminant <value> |
SEM0150 | Stable code for an explicit scalar enum discriminant outside its representation range. | Enum discriminant <value> is outside <representation> |
SEM0151 | Stable code for an implicit scalar enum successor outside its representation range. | Implicit enum discriminant after <predecessor> exceeds <representation> |
SEM0152 | Stable code for a negative discriminant under an unsigned scalar enum representation. | Unsigned enum representation <representation> cannot hold <value> |
SEM0153 | Stable code for a member missing from a resolved scalar enum. | Enum <enumName> has no member <member> |
SEM0154 | Stable code for a canonical member used through or required by another enum. | Enum member of <actual> cannot be used as <expected> |
SEM0155 | Stable code for implicit mixing between a scalar enum and an integer. | <integer> does not implicitly construct <enumName><enumName> does not implicitly convert to <integer> |
SEM0156 | Stable code for equality between distinct canonical scalar enums. | Equality requires one enum type, not <left> and <right> |
SEM0157 | Stable code for direct ordering of scalar enum values. | Enum <enumName> does not support <operator>; compare backing values explicitly |
SEM0158 | Stable code for a scalar enum match that leaves canonical members uncovered. | Match over <enum> does not cover <join> |
SEM0159 | Stable code for a repeated unguarded scalar enum member arm. | Duplicate enum match arm <member> |
SEM0160 | Stable code for a scalar enum arm following an unguarded wildcard. | Enum match arm is unreachable after `_` |
SEM0161 | Stable code for a scalar enum pattern naming a member of another enum. | Enum pattern from <actual> cannot match <expected> |
SEM0162 | Stable code for an integer literal pattern used against a scalar enum. | Integer pattern <value> cannot match enum <enum> |
SEM0163 | Stable code for effect-block return sites whose success types disagree. | Effect block return sites have incompatible types: <join> |
SEM0164 | Stable code for a nominal union declaration with no variants. | Union <unionName> must declare at least one variant |
SEM0165 | Stable code for a repeated variant name within one nominal union. | Duplicate union variant <spelling> |
SEM0166 | Stable code for a named-field variant whose braces contain no field. | Union variant <variantName> must omit braces or declare at least one field |
SEM0167 | Stable code for a variant selector absent from its resolved nominal union. | Union <unionName> has no variant <variantName> |
SEM0168 | Stable code for a variant qualifier that does not name a nominal union. | Expected a nominal union, found <actual> |
SEM0169 | Stable code for construction through an incomplete nominal union declaration. | Cannot construct invalid nominal union <unionName> |
SEM0170 | Stable code for a duration literal whose exact nanosecond total exceeds u64. | Duration literal exceeds the u64 nanosecond range |
SEM0171 | Stable code for postfix referent projection whose subject is not a reference. | Cannot project a referent from <actual>; the subject must be a reference |
SEM0172 | Stable code for positional construction with the wrong number of tuple elements. | <type> expects <expected> tuple elements but received <actual> |
SEM0173 | Stable code for using tuple syntax with a named struct or record syntax with a tuple. | A contextual <expected> literal cannot construct <actual> |
SEM0174 | Stable code for attempting to join distinct anonymous aggregate occurrences. | Separate anonymous aggregate occurrences do not acquire a common type |
SEM0175 | Stable code for attempting named-field construction of a positional aggregate. | <type> is positional and cannot be constructed with named fields |
SEM0176 | Stable code for crossing from static evaluation into unavailable runtime work. | <operation> is not available during static evaluation for <target> |
SEM0177 | Stable code for a selected source-requested compile failure. | <detail> |
SEM0178 | Stable code for a cycle in one demanded static application. | Static evaluation of <application> is cyclic for <target> |
SEM0179 | Stable code for exhausting the static evaluator's deterministic step budget. | Static evaluation exceeded its step limit of <limit> for <target> |
SEM0180 | Stable code for exhausting the static evaluator's logical call-depth budget. | Static evaluation exceeded its call-depth limit of <limit> for <target> |
SEM0181 | Stable code for exhausting the static evaluator's retained-value budget. | Static evaluation exceeded its retained-value limit of <limit> bytes for <target> |
SEM0182 | Stable code for exhausting the static evaluator's residual-growth budget. | Static evaluation exceeded its residual-growth limit of <limit> nodes for <target> |
SEM0183 | Stable code for a type alias whose target resolves back through the alias itself. | Type alias <alias> is cyclic: <join> |
SEM0184 | Stable code for a type alias that declares type parameters. | Type alias <alias> cannot declare type parameters; alias an applied type such as Point<i32> instead |
SEM0185 | Stable code for a foreign function whose ABI string is not "C". | Foreign ABI "<abi>" is not supported; only "C" is available |
SEM0186 | Stable code for a foreign function declared without the mandatory unsafe qualifier. | Foreign function <name> must be declared unsafe |
SEM0187 | Stable code for a foreign parameter or result type outside the C-compatible scalar subset. | <type> is not admitted by the <abi> ABI |
SEM0188 | Stable code for Silk-only contract syntax retained on a foreign function declaration. | A foreign function declaration must not include <restriction> |
SEM0189 | Stable code for using a foreign function as a first-class value rather than calling it. | Foreign function <name> can only be called; it cannot be used as a first-class value |
SEM0190 | Stable code for a native symbol that is not an ASCII identifier. | "<symbol>" is not a valid native symbol; use a letter or underscore followed by letters, digits, or underscores |
SEM0191 | Stable code for a native symbol the compiler reserves for its own runtime or entry. | Native symbol <symbol> is reserved by the compiler runtime |
SEM0192 | Stable code for two reachable declarations of one symbol with different C signatures. | Foreign symbol <symbol> is declared with a conflicting C signature or behavioral contract |
SEM0193 | Stable code for one reachable foreign call unavailable on the requested execution surface. | Foreign function <symbol> is unavailable for <surface> |
SEM0194 | Stable code for an inherent impl head that is not the whole family of a module-local nominal. | impl <owner> must name the whole type family: its arguments are exactly the impl's own binders, in order, each onceimpl <owner> cannot bound its binders; inherent members belong to every instantiationimpl <owner> must be declared in the module that declares <owner>impl <owner> cannot use a type alias as its owner; name the aliased nominal type insteadimpl <owner> must name a struct, union, enum, service, or interface declaration |
SEM0195 | Stable code for an inherent impl member that cannot be an associated member. | impl <owner> cannot map <member> to another declaration; only a conformance maps operationsimpl <owner> cannot declare a drop hook; declare impl Drop for <owner> instead<owner>.<member> collides with the <collidesWithexistingitem> <member> of <owner> |
SEM0196 | Stable code for two inherent members of one owner sharing a name. | <owner>.<member> is declared more than once; one owner has at most one member of each name |
SEM0197 | Stable code for a selective import naming an inherent member as if it were a root declaration. | <module> has no root declaration <member>; it is a member of <owner>, so import <owner> and write <owner>.<member> |
SEM0198 | Stable code for an associated function called on a value as though it had a receiver. | <owner>.<member> is an associated function without a receiver; call it as <owner>.<member>(...) |
SEM0199 | Stable code for nesting one anonymous callable body inside another in the first language slice. | Anonymous callable bodies cannot be nested in this language slice |
SEM0200 | Stable code for a receiver operation declared by more than one bound of one type parameter. | <member> is declared by more than one bound of <parameter> (<join>); call it through the bound, as <at0Bound>.<member>(...) |
SEM0201 | Stable code for an export "C" function whose body may suspend. | Exported function <symbol> may suspend; a C-callable body must be synchronous |
SEM0202 | Stable code for a receiver operation supplied by more than one of the receiver's conformances. | <member> is supplied to <receiver> by more than one interface (<join>); call it through one, as <at0Interface>.<member>(...) |
SEM0203 | Stable code for naming a conformance-supplied receiver operation as a value instead of calling it. | <member> is supplied to <receiver> by an interface and must be called; it has no value form |
SEM0205 | Stable code for a C-layout record that declares type parameters. | C-layout record <record> cannot declare type parameters |
SEM0206 | Stable code for a C-layout record field outside the closed C object subset. | Field <field> of C-layout record <record> has unsupported type <type> |
SEM0207 | Stable code for a value that cannot become an exact noncapturing C callback address. | <name> cannot be used as a C callback: <detail> |
SEM0208 | Stable code for reachable C data on an execution surface without native symbol linkage. | Foreign static <symbol> is unavailable on <surface>; C data symbols require native LLVM linkage |
SEM0209 | An explicit lifetime does not name a binder in its lexical header scope. | Unknown lifetime <spelling> |
SEM0210 | An omitted output region has no unique declaration-level input relationship. | The omitted output lifetime has no unique input; name its lifetime explicitly |
SEM0211 | A lifetime binder or outlives bound has an unsupported declaration shape. | Invalid lifetime binder: <detail> |
SEM0212 | Lifetime <longer> does not outlive <shorter> | |
SEM0213 | Type <type> does not remain valid for <lifetime> | |
SEM0214 | Stable code for rejected profile inputs, package schemas, defaults, or predicates. | Invalid compilation configuration: <message> |
SEM0215 | Stable code for invalid raw-pointer alignment, address space, or qualifier conversion. | Invalid pointer qualifier <qualifier>: <detail> |
SEM0216 | A diagnostic observer callback lacks a complete direct-execution proof. | Diagnostic observer callback requires direct execution: <detail> |
SEM0217 | Terminal observation is provably outside a selected failure handler. | Terminal diagnostic observation requires a selected failure context |
SEM0218 | A test qualifier marks a function outside the finite executable test contract. | Invalid test declaration: <detail> |
Ownership (OWN)
| Code | Meaning | Reported as |
|---|---|---|
OWN0001 | Stable code for a use of a binding after its consuming move. | <spelling> was moved and cannot be used again |
OWN0002 | This place crosses a boundary that does not support partial moves | |
OWN0003 | Moving <spelling> requires an explicit move | |
OWN0004 | Assignment to <spelling> consumes the same owner before replacement commits | |
OWN0005 | Loop <loop> repeats with incompatible owner liveness | |
OWN0006 | Borrowed pattern binding <spelling> cannot escape its match arm | |
OWN0007 | Exclusive match requires mutable binding <spelling> | |
OWN0008 | Match guard cannot consume pattern binding <spelling> | |
OWN0009 | <access> match requires a complete binding place | |
OWN0010 | <requested> borrowed-view loan conflicts with an active <toLowerCase> loan | |
OWN0011 | <toLowerCase> access to <spelling> conflicts with an active borrowed-view loan | |
OWN0012 | A non-Copy value cannot be moved out through a borrowed-view place | |
OWN0014 | Stable code for invoking a stored callable through too weak an aggregate receiver access. | Cannot invoke field <field> of <aggregate> through <toLowerCase> aggregate access: <contract> requires <toLowerCase> access to the whole aggregate |
OWN0015 | Stable code for running a stored Effect through too weak an aggregate receiver access. | Cannot run field <field> of <aggregate> through <toLowerCase> aggregate access: <contract> requires <toLowerCase> access to the whole aggregate |
OWN0016 | Stable code for an access-scoped local-shared borrow escaping or crossing suspension. | Local-shared access cannot suspend while its exclusive borrow is liveLocal-shared access cannot invoke an external readiness callback while its exclusive borrow is liveLocal-shared access callback cannot return a value that retains its exclusive borrow |
OWN0017 | Stable code for an owner consumed in only some arms of a branch merge. | Branches merge with incompatible owner liveness for <spelling> |
OWN0018 | Stable code for returning a callable or Effect that borrows storage owned by the returning function. | <executable> cannot escape with a <toLowerCase> borrow of local <spelling> |
OWN0019 | A borrowed value is used beyond the validity of its referent. | Lifetime <lifetime> does not remain valid at this use |
OWN0020 | An owner cannot be preserved by the suspension frame at this run boundary. | Cannot preserve ownership across suspension: <detail> |
Layout (LAY)
| Code | Meaning | Reported as |
|---|---|---|
LAY0001 | Stable code for an exact usize or isize literal outside the selected target word. | <type> literal <spelling> exceeds the <bits>-bit range for <target> |