velt/generate

private, or an ES private field (#x, whose name keeps the #).

An object literal's getter (get k() { … }): type is what it returns.

A private field a std type, or a type of a package with a native library, declares (its runtime state: a handle), also in a class extending it.

A field the type's objects hold for an extension (interface E extends T with optional fields, whose objects are T's): code reads it from the value seen as type via (-1: a field of the type itself).

The type with id id.

Appends code to the body.

Appends one line of code to the body.

Adds a top-level declaration (a helper function or constant) next to the instance.

A name for a helper that no other instance uses.

The name of the function generated for instance fn<args…> of a generated function of the same generator module (generated in the same run when it is new): code calls it with the arguments fn takes.

How generated code writes model type id.

s as a Velt string literal.

Reports an error at at (a type's or a field's at; -1: at each call that needs the instance). The first line of message is the error, each further line a note; labels point at other places of the model ([at, text], such as a field's declaration).

The body written so far.

The names of the instance's parameters, in order.

The generator key of the instance being generated.

number, boolean, string, void, never, symbol, literal, enum, array, tuple, option, union, object, class, struct, interface, map, record, set, shared, date, function (also a function with properties), generator, any, unknown, promise or opaque.

As messages show it (User, number[]).

<module path>::<name> of a declared type, else "".

How generated code writes the type ("" when it cannot be named).

f64, i32, … for numbers.

Element (array, set), payload (option, promise, shared), key and value (map, record), tuple elements or type arguments, by kind.

The members of a union, in order.

Fields of objects, classes and structs, inherited ones first.

A class's base class (-1: none) and the classes of the program that extend it.

Members of an enum.

The value of a literal type as JavaScript source ("a", 1, true); a string is also its JSON text. For an option: what it holds when empty (null, undefined or null | undefined).

The methods std's operations call by name (toJSON, toString, the inspect hook keyed by Symbol.for("nodejs.util.inspect.custom")).

Whether a value of this type may be a typed Proxy standing for it (a class or object type in a program that uses Proxy): only then does a generator need a path for proxies.

A function with properties (Object.assign(f, { … })).

A class used as a value (typeof C: its constructor and statics).

A dynamic type: any, unknown, and also object and Function (kind interface), whose values say at run time what they hold.

For a std type, or a type of a package with a native library, whose structure the model does not show (opaque, set): the private field that keeps its state (a runtime handle), else "".

A struct's or class's constructor when it is not public (private, protected), else "": code that builds a value without running the constructor (__construct) bypasses it.

The public static methods of a class that return one (its factories), sorted.

Where it is declared, for Output.error (-1: nowhere).