Esta página aún no está traducida al español. Leer la versión en inglés

Diagnostics

How Antril reports errors, and what each AN code means - from the lexer, the parser, declarations and bodies - plus the borrow and region errors Larva reports.

Última actualización: 14 min de lectura Editar en GitHub

En esta página

How errors look

The compiler reports each problem with the file, the line and column where it starts, a code and a message:

Antril
Main() { throw 5; }
Terminal
larva build --check
C:\work\App\Program.ant(1,16): error AN2007: only objects are thrown, not a `i32`

The same diagnostics appear in the editor as you type (through larva lsp), and larva build --check reports them without building.

Codes starting with AN come from Antril:

Range From What it checks
AN0001–AN0007 The lexer Characters, comments, numbers, strings.
AN0010–AN0039 The parser The shape of declarations, statements and expressions.
AN1001–AN1105 Declarations Types, members, signatures, inheritance, constants, interop.
AN1400–AN1422 Declarations Access, and variadic templates.
AN2001–AN2145 Bodies Names, types, calls, conversions, statements, patterns.

Errors written in brackets, such as error[ConflictingBorrow], come from Larva, which checks the program after Antril has compiled it: borrows, regions and unsafe operations. They carry a name instead of a number:

Error What it means
ConflictingBorrow A place is used, assigned or borrowed while an exclusive borrow of it lives, or borrowed &mut twice.
MutationThroughSharedReference Something is written through a &T.
ReturnsLocalReference A function returns a reference to its own local.
CopyOfNonCopy A value that cannot be copied is copied through a reference.
RegionEscape An object made in a region is still used after the region ends.
UnsafeRequired An unsafe operation (such as delete) outside unsafe code.

The borrow errors are warnings with borrowcheck: warn (warning[ConflictingBorrow]) and do not stop the build; see Memory. Antril's own diagnostics are all errors.

The tables below list the codes you are likely to meet. The message itself always says more, with the names involved.

Lexer

Code Meaning
AN0001 A character that is not part of Antril.
AN0002 A /* comment without its */.
AN0003 An invalid number: no digits, or a float written in hexadecimal or binary.
AN0004 A string without its closing " on the same line.
AN0005 An invalid character literal: empty or unclosed.
AN0006 A lone } in an interpolated string: write }}.
AN0007 An interpolation hole without its closing }.

Parser

Code Meaning
AN0010 Something expected is missing: ';', ')', a name…
AN0012, AN0016 A token that cannot start a member or a statement there.
AN0013 The same modifier twice.
AN0014 Modifiers or attributes not followed by a declaration.
AN0015 Something other than get or set inside a property.
AN0017 A loop (…; …; …) without ; between its condition and its step.
AN0018 A try with neither catch nor finally.
AN0019 An expression is expected.
AN0020 A function written with its result first: write Name(…) : T.
AN0021 An invalid operator symbol, a reserved one (=, ., =>, ?, .., ..=, ->, ...), or the wrong number of operands.
AN0022 An operator declared outside a type: operators are members of the type of an operand.
AN0023 An operator without a result type.
AN0024 A base get or base set accessor with a body.
AN0025 left or right on an operator with two operands, or on a conversion.
AN0026 A conversion op (T)(…) with more than one operand.
AN0027 A symbol declared with associativity(Associativity.None) chained: write parentheses.
AN0028 fixed(N) in a constraint without a positive number of bytes.
AN0029 An extension that names a receiver when static, or none when not.
AN0030 reactive, computed or reacts outside a class.
AN0031 reactive, computed or reacts with static, or two of them together.
AN0032 computed with accessors, or reactive on a property.
AN0033 A reacts method with parameters, a result, or no body.
AN0034 An import list without from, or a different number of aliases and names.
AN0035 const not followed by a local declaration.
AN0036 from on a static loop that is not among a type's members, or not followed by a small number.
AN0037 A tuple type of one type: (i32).
AN0038 Two access words on one declaration.
AN0039 into namespace in the header of a member of a type.

Declarations

Types and inheritance

Code Meaning
AN1001 Something other than a type, function or field at the top level.
AN1002 A type declared twice with the same full name.
AN1006 An enum base that is not an integer type, str or a value.
AN1008 A second base that is not an interface (a class has one base class, first), or a base class on something that is not a class.
AN1009 Deriving from a final class.
AN1010 A type that inherits from itself.
AN1012 The wrong number of type arguments.
AN1013 str or any without the core library.
AN1014 An unknown type name.
AN1015, AN2021 An array of more than 8 dimensions.
AN1016 A type that cannot be nullable.
AN1019 An enum member's value that cannot be computed (it divides by zero, or a value-based member has none).
AN1032 A constructor in a type that is not a class or a value.
AN1034 A class that leaves methods of its base classes or interfaces without a body.
AN1035 More than one Main.
AN1043 A property in a type that is not a class, value or interface.
AN1045 A type that implements an interface but lacks one of its methods, properties or operators.
AN1063 An enum with more than one base.
AN1064 A bitflag enum whose base is not an integer type.
AN1076 A record class with a base class, or a class derived from a record class.
AN1077 destroy() in a value, interface or enum.
AN1079 An object of a library built for another gc: mode is used.
AN1096 An attribute or exception whose base is not an attribute or exception, or a program without the core library's Attribute / Exception.
AN1105 A static class used as the type of a variable, field, parameter, result, element, type argument or cast.

Members

Code Meaning
AN1020 A field declared twice.
AN1021, AN1023 A void field or parameter.
AN1022 A static field of a generic type that does not start with a constant.
AN1024 Two parameters with the same name.
AN1026 An async function without a body.
AN1027 A function without a body where one is needed (only instance methods of a base class, and interface methods, may leave it out).
AN1029 virtual or override on something that is not an instance method of a class.
AN1030 Two methods with the same name and parameters.
AN1031 A name used both for a field or property and for a method.
AN1033 Two constructors with the same parameters.
AN1036 override on a method that overrides nothing.
AN1037 An override with a different result type.
AN1038 A method that replaces a virtual one without saying override.
AN1039 Overriding a final method.
AN1044 A property without get.
AN1047 base get / base set outside an interface.
AN1048, AN1049, AN1050 A static constructor with parameters or a call to another constructor; two of them; one in a generic type.
AN1074 A fixed field that is static.
AN1075 Fields, properties or constructors in an extension block, or a parameter named like the receiver.
AN1078 A destructor that is static, or has parameters, a result or type parameters.
AN1097, AN1098, AN1099 An array kept in the object (fixed T[]) in the wrong place, without : fixed(n) in a constructor, or used as an array value.
AN1100 virtual in a type nothing can derive from.
AN1101 final on a method without override.
AN1102 virtual, override or final on a field.
AN1103 A field in a namespace: make it a const, or put it in a type.
AN2131 A parameter of a bodiless constructor that names no field and is not passed to : base(…).

Constants and fixed sizes

Code Meaning
AN1073 A fixed array length that is not a positive constant, sizeof(T) or N * sizeof(T).
AN1086 const with static, readonly, fixed or reactive.
AN1087 A constant without a value.
AN1088 A type that cannot be a constant (arrays, classes).
AN1089 A constant value not made of constants.
AN1090 Constants that depend on each other in a cycle.
AN1091 A constant whose value is not known when compiling.

Operators

Code Meaning
AN1065 A symbol declared again with another precedence or associativity.
AN1066 A precedence on a built-in symbol, which keeps its own.
AN1067 A new binary symbol without a precedence.
AN1068 A precedence on an operator with one operand.
AN1069 A precedence that is not a level of PrecedenceLevel, a number, or a constant enum member.
AN1072 An operator's type parameter that appears in no operand.

Imports, access and templates

Code Meaning
AN1084 An import of a namespace that does not exist, or of a name it does not have.
AN1085 A name imported twice.
AN1092 A reference type (&T) while the borrow checker is off.
AN1093 An access word that does not apply in a namespace (inherited, friendly; private on a type).
AN1094 inherited on a member of a type nothing can derive from: write private.
AN1095 An access word on an interface member.
AN1104 Unsafe code or a pointer type in a project with unsafe: deny.
AN1400, AN1401 A type or member used where its access does not allow it.
AN1420 A type parameter pack (T...) that is not the last, or a static loop outside a variadic template.
AN1421 A pack used as a single type.
AN1422 A static loop over a pack other than the template's.

Attributes and interop

Code Meaning
AN1003, AN1004 [Primitive] misused (core library only).
AN1040 A constraint that names something other than an interface or class.
AN1042 An extern runtime service with a body or type parameters (core library only).
AN1046 A constraint word whose interface needs the core library.
AN1051, AN1052 [Import] on a function with a body or type parameters, or without the library's name.
AN1053, AN1054 An imported function taking or giving a type C cannot hold.
AN1055, AN1056 [Export] on something that is not a static function with a body, or with types C cannot hold.
AN1057 A func* type with parameters or a result C cannot hold.
AN1058, AN1059, AN1060 An attribute that is not an attribute class, is abstract, or has no constructor for these arguments.
AN1061, AN1062 Name = value in an attribute naming no field or property, or not a constant.
AN1070, AN1071 [FriendOf] that does not name one type, or names the type itself.
AN1080–AN1083 [ValueLayout] / [FieldOffset] misused (see Interop).

Bodies

Names and members

Code Meaning
AN2002 base in a type without a base class.
AN2003 A local declared twice in the same scope.
AN2004 A local named like a parameter.
AN2029 this in a static function.
AN2030, AN2047 base used other than to call a base method (base.Name(…)).
AN2031 A method used without calling it.
AN2032 A type used as a value.
AN2033 An unknown name.
AN2034, AN2046 An instance field or method used in a static function.
AN2036, AN2050 An instance member used through the type, or a type without that function.
AN2037, AN2092 A static member a type parameter's constraint does not declare.
AN2038, AN2054 A static member used through a value: write Type.Member.
AN2039 A type without that member.
AN2040 A member read on a value that may be null: check it first (is, ??, ?.).
AN2045 An unknown function.
AN2048, AN2049 base.M() where no base has M, or its M has no body.
AN2051 A namespace without that function.
AN2052, AN2053 A type with no methods, or without that method.
AN2091 A generic type's static member read without its type arguments.
AN2141 nameof of something that is not one existing name.

Calls and constructors

Code Meaning
AN2056 A function value called with the wrong number of arguments.
AN2057 No overload takes these argument types.
AN2058 Two overloads fit equally well: cast an argument.
AN2059 new on something that is not a class or value.
AN2060 new on a static class.
AN2061 new on a base class.
AN2062 new with arguments on a type without such a constructor.
AN2093 Type arguments that cannot be inferred: write them.
AN2094, AN2101, AN2102, AN2124–AN2128 A type argument that does not meet its parameter's constraint.
AN2100 A lambda parameter whose type cannot be inferred: write it.
AN2125 new T(…) without a T : new(…) constraint.

Types and conversions

Code Meaning
AN2008, AN2009 return with a value in a function that returns nothing, or without one in a function that returns something.
AN2001 A function or lambda that does not return a value on every path.
AN2015 A void variable.
AN2016 A variable without a value, of a type with no default.
AN2020 as between types that are not object types.
AN2022 new T[n] of a type with no zero value: use T?.
AN2023, AN2044 An array length or index that is not an integer.
AN2024 An empty array literal with no type to take.
AN2028 A literal that does not fit its suffix's type.
AN2042, AN2043 Indexing something that cannot be indexed, or with the wrong number of indexes.
AN2063, AN2064, AN2065 -, ~, ++ or -- on a type that does not have them.
AN2070 Assigning a readonly field outside its constructors.
AN2071, AN2140 Assigning a constant, or part of one.
AN2072 Assigning something that is not a variable, field, element or property.
AN2073, AN2074, AN2076, AN2078 An operator on types it does not work on.
AN2075 Comparing with null a value that is never null.
AN2079 ?? on a left side that is never null.
AN2080 ?: branches with no type in common.
AN2081 null where the type is not nullable.
AN2082 A downcast to a nullable type: cast to T, or test with as.
AN2084 A value that does not convert to the type expected (a cast may be needed).
AN2095 Assigning a property without set.
AN2097, AN2138 A record field with no ToString() or Hash().
AN2098 + on strings without the core library.
AN2099 x op= v where op does not give x's type.
AN2123 No type of the operands declares this operator for them.
AN2132, AN2133 with on something that is not a record, or naming a field it does not have.
AN2134 == on a nullable record without testing for null.
AN2142, AN2143 A tuple size without the core library, or null in a tuple with no type to take.

Statements

Code Meaning
AN2006 throw; outside a catch.
AN2007 Throwing something that is not an object.
AN2010 break outside a loop or switch.
AN2011 continue outside a loop.
AN2012 delete of something that is not a class object.
AN2014 A loop counter that is not an integer.
AN2017 A catch of a type that is not an object type.
AN2026 A range outside a loop or a pattern.
AN2110–AN2113 yield misused (see Iterators).
AN2114–AN2117 async and await misused (see Async).

Patterns

Code Meaning
AN2085 A switch expression with no arms.
AN2086 <, >… in a pattern on a type that is not a number.
AN2088, AN2089 A type pattern that can never match.
AN2090 A constant pattern of the wrong type.
AN2135, AN2136 A positional pattern with the wrong number of positions, or on a type without positions.
AN2137 A property pattern naming a member the type does not have.

Unsafe code, references and interop

Code Meaning
AN2066 &x (an address) outside unsafe code.
AN2067 *p or p[i] through a pointer outside unsafe code.
AN2068 * on something that is not a pointer.
AN2083 A pointer cast outside unsafe code.
AN2118 &F that does not name exactly one fitting static function.
AN2119 &F of a function whose types C cannot hold.
AN2120 Calling a func* outside unsafe code.
AN2121 Pointer arithmetic outside unsafe code.
AN2122 An operator a pointer does not have (p * 2).
AN2144 &x or &mut x while the borrow checker is off.
AN2145 & of something that is not a place (a local, parameter, field or element).

Other

Code Meaning
AN2018 A character literal of more than one character.
AN2019, AN2025 nameof or typeof without the core library.
AN2027 GetLength without its dimension.
AN2139 $resource("name") naming no resource of the project's RESOURCES chunk.

A few codes say that a construct "comes in a later phase" (AN1018, AN2013, AN2055, AN2069, AN2077, AN2087, AN2096): the compiler recognizes it but does not compile it yet. AN9999 is an internal error of the compiler; please report it with the code that causes it.

¿Te resultó útil esta página?

No se guarda ninguna dirección; tu nombre de usuario sí, si iniciaste sesión.

Editar esta página en GitHub Reportar un problema

Esc