Cigma — Developer Guide

Cigma is an experimental programming language designed to take advantage of modern C++ within a simplified and redesigned syntax. Cigma programs can be more concise and (once learned) easier to read than equivalent C++ programs, while remaining fully interoperable with existing C++ code and toolchains.

The Developer Guide explains how the Cigma programming language is implemented and is meant for people wishing to contribute to the project, refer to the User Guide to learn about the language itself.

Compilation

This project uses CMake as its build system. At least version 3.3 is required (however running the tests requires C++20 support, which is only available from 3.12). ¶

The reference implementation of the Cigma language is written in C++11 and a compatible compiler is required. GCC, Clang and Visual Studio are known to work. ¶

The flex lexer generator is required to build the reference parser. ¶ The reference implementation of the language uses the bison parser generator. Bison 3 or newer is required. When building on Windows a precompiled version of flex and bison will be downloaded automatically. ¶

The documentation is generated using docra. This tool and AsciiDoctor are required to generate the document you are currently reading. ¶

Once you have all the prerequisites, you can launch the build system.

Linux

Create a build directory
```
mkdir -p build/dir && cd "$_"
```
Configure the build system in it
```
cmake /path/to/source/cigma
```
Build!
```
make
```

Windows

Visual Studio, as of version 15.5, is capable of opening and configuring CMake projects directly, just open the source code folder using File Open Folder then do CMake Build All once configured. ¶

Targets

The build system provides the following targets:

bison_check: Reports errors or conflicts in the reference Bison grammar. ¶
bison_sync: Uses yppsync to update helper code within the reference Bison grammar. ¶
bison_unsync: Uses yppsync to remove helper code from the reference Bison grammar. ¶
boot_ast: Library containing the reference implementation of the Cigma grammar. ¶
boot_cpp: Bootstrap library to translate Cigma ASTs into compilable C++ code. ¶
boot_dot: Bootstrap library to print Cigma ASTs in Graphviz DOT format. ¶
boot_yml: Bootstrap library to print Cigma ASTs in YAML format. ¶
install: Default CMake installation target. ¶
uninstall: Remove files copied by the install target. ¶
yppsync: This is an internal development tool used to simplify the implementation of the reference Bison parser. ¶

Bootstrapped implementation

The Cigma programming language is designed to map very closely to modern C++. For this reason, the simplest way to compile Cigma programs is to translate them into C++ code first, and then compile the result using any C++ toolchain.

The first implementation of such a translator is being written in C++11, and will be used to bootstrap a second translator, written fully in Cigma. This section describes the implementation of this first-level translator.

Grammar

One of the explicit design goals of Cigma is to have a regular grammar without ambiguities (much unlike C++, that is highly non-regular and notoriously difficult to parse), all while retaining the expressive power of modern C++. After a lot of iteration, the current Cigma grammar manages to express C++20 programs using a much simpler (and, arguably, more readable) LALR(1) grammar. This section describes the current implementation of the grammar, built using the classical combination of Bison and Flex.

Parser

The Bison compiler-compiler is able to generate parsers for different kinds of grammars, the simplest ones being LALR(1). LALR(1) grammars require no backtracking and use only a single lookahead token in order to decide the next grammar rule to follow. These limitations produce fast parsers but impose lots of constraints on the design of the language, which delayed the development of the Cigma language for a long time.

Lexer

Abstract syntax tree

Memory management

Identifiers

Attributes

Expressions

Blocks

Types

Declarations

Constraints

Flow-control

Name resolution

C++ translation

Initialization

Initialization in C++ is unfortunately a very complex topic, there exist tens of possible initialization syntaxes, each with its own issues. Despite long and ongoing modernization efforts there still isn’t a generic, concise and consistent set of rules for C++ initialization. When mapping (unambiguous) Cigma initialization syntax to (ambiguous) C++ initialization syntax, the translator implements the following guidelines. ¶

Guidelines for direct initialization

Direct initialization uses <(…) syntax and invokes constructors, including constructors on predefined types ( bool, int, …).

Zero arguments

Should translate to T t = T() if both name and Type are available at the callsite.
Should translate to T() if only the Type is available.
Should translate to t() if only the name is available.

Why

(1) does not suffer from most vexing parse, unlike T t()
(1) is also used by the STL to always enforce direct default initialization regardless of the Type

One argument

Should translate to T t(arg) if both name and Type are available at the callsite.
Should translate to T(arg) if only the Type is available.
Should translate to t(arg) if only the name is available (implicit initialization must be allowed).

Why

(1) does not suffer from most vexing parse, unlike T t(arg)
Works with predefined types ( int a({42}) raises a warning)
(1) does not accidentally create an std::initializer_list (in particular if T is auto, since C++-11 with current compilers)

This form does allow narrowing conversions. Uniform initialization would have prevented narrowing conversions but at the same time it makes it easy to call the std::initializer_list constructor by accident. Using this form, something like :/std:list[:!int]<(10) will have the expected result (create a list of ten elements), instead of accidentally creating a list containing a single element with value ten, the second meaning can be unambiguously expressed with aggregate initialization, like :/std:list[:!int]<{10}.

More arguments

Should translate to T t(arg1, arg2, …) if both name and Type are available at the callsite.
Should translate to T(arg1, arg2, …) if only the Type is available.
Should translate to t(arg1, arg2, …) if only the name is available (implicit initialization must be allowed).

Why

Prevents accidentally calling std::initializer_list constructors (for example in std::vector)

This form was chosen to avoid ambiguities for the same reason as the case above, however this allows narrowing conversions in constructor calls. ¶

Guidelines for aggregate initialization

Aggregate initialization uses <{…} syntax and initializes individual fields in user-defined aggregates (or calls the aggregate constructor if available).

Zero arguments

Should translate to T t{} if both name and Type are available at the callsite.
Should translate to T{} if only the Type is available.
Should translate to t{} if only the name is available.

Why

Applies to enums as well as other user-defined types (if T is a template parameter <() should be preferred as it default initializes both aggregates and non-aggregates)

One argument

Should translate to T t = {arg} if both name and Type are available at the callsite.
Should translate to T{arg} if only the Type is available (and it is not auto).
Should translate to t{arg} if only the name is available.

Why

Equals sign in (1) is required when T is auto to consistently obtain an std::initializer_list

More arguments

Should translate to T t = {arg1, arg2, …}
Should translate to T{arg1, arg2, …} if only the Type is available (and it is not auto)
Should translate to t{arg1, arg2, …} if only the name is available

Why

Equals sign in (1) is required when T is auto to generate an std::initializer_list
Equals sign not required anymore for templified containers like std::array if using C++-11 post CWG 1270 or C++-14 and beyond ¶

Guidelines for copy initialization

Save for the exceptions mentioned above, the translator should never emit copy initializers (using an equals sign) in its C++ output, and always favour uniform initialization instead. ¶

Implementation of initialization guidelines

Depending on the surrounding context, the guidelines just described result in the following behaviour. ¶

Declaration group

A ast::DeclGroup is used wherever multiple names can be declared with the same Type (and possibly the same initializer), typical examples are function arguments, members and local variables. Within this context, the following initializers can be found: ¶

ast::ExprCtor: Performs explicit direct initialization. Since the Type name is known at the callsite we the follow the above guidelines directly. (TODO) ¶
ast::ExprInitList: Performs explicit aggregate initialization with positional (not designated) initializers. Here we can also follow the guidelines directly. This is encountered for example when initializing an array. ¶
ast::ExprsByMember: Performs explicit aggregate initialization like above, but with designated initializers (only available since C++20). (TODO) ¶
ast::Expr: The Type is being initialized with an equals sign only, according to the guidelines a single-argument list initializer should be emitted. There is one exception when setting default values for function and template arguments, where braces are not supported in all compilers, and another when the Type is auto, as that generates an std::initializer_list. = to work around MSVC bug https://developercommunity.visualstudio.com/content/problem/1232251/error-in-brace-initialization-of-pointer-to-functi.html ¶ const int X = {42} syntax so we must omit the brackets there as well (although that’s fine for GCC). ¶

Constructor declaration

A ast::DeclCtor is used to declare constructors. Such a declaration may contain initializers that are used to initialize base classes or class members. Within this context, the following initializers can be found: ¶

ast::ExprCtor: Should emit a delegated constructor. (TODO) ¶
ast::ExprsByPos: Initializes class members by position (not by name). Translating this syntax requires iterating over the struct or class members. (TODO) ¶
ast::ExprsByMember: Initializes class members by name. Since the name is available, the initialization guidelines can be followed directly. (TODO) ¶
ast::ExprsByBase: Initializes base classes (this is basically a list of ast::ExprInitType ). (TODO) ¶
ast::ExprInitType: Initializes a single base class. This stage is reached via recursion from the previous case. (TODO) ¶
ast::Expr: This combination is probably impossible in the current grammar and should raise an error. (TODO) ¶

Type initialization

A ast::ExprInitType is an initializer that explicitly describes the name of the Type being constructed (as a ast::TypePath ) in addition to the expression (or expressions) to initialize it with. In this context, the initializer is used in expressions and not as part of a base class initializer. ¶

ast::ExprCtor: Calls the constructor for the given Type. The result can be used for direct initialization. The guidelines still apply given that the Type name is known. (TODO) ¶
ast::ExprInitList: Performs explicit list initialization using a braced-init-list according to the guidelines. (TODO) ¶
ast::ExprsByMember: This could be used to explicitly initialize a temporary using designated initializers. (TODO) ¶
ast::Expr: Explicitly call constructor with a single argument, as per the guidelines. (TODO) ¶

Positional expression group

A ast::ExprsByPos is not an initializer per se, but it may be found by recursion when visiting other kinds of initializers. From the guidelins, this should always be translated into a braced-init-list. ¶

Member-wise expression group

The group ast::ExprsByMember is of course used to initialize members by name. As such, when emitting C++ initializers for it it is just necessary to recurse into the appropriate initializer generator for each member. ¶

Anything else

TODO ¶

Self-hosted implementation

Once the bootstrapped translator will be able to understand and correctly translate to C++ a large enough subset of the Cigma programming language, a self-hosted translator will be implemented in Cigma itself.

Appendix A: Bootstrap AST

`ast::Attr`

struct Attr : Node {...};

stages/boot/ast.hpp:1008

`ast::AttrBlock`

stages/boot/ast.hpp:1052

`ast::AttrPath`

stages/boot/ast.hpp:1033

`ast::Block`

struct Block : Node {...};

stages/boot/ast.hpp:2706

`ast::Comment`

struct Comment : Note {...};

stages/boot/ast.hpp:349

`ast::Decl`

struct Decl : Node {...};

stages/boot/ast.hpp:1313

`ast::DeclConcept`

stages/boot/ast.hpp:3359

`ast::DeclCtor`

struct DeclCtor : Decl {...};

stages/boot/ast.hpp:1501

`ast::DeclDtor`

struct DeclDtor : Decl {...};

stages/boot/ast.hpp:1524

`ast::DeclForeign`

struct DeclForeign : Decl {...};

stages/boot/ast.hpp:1595

`ast::DeclGroup`

struct DeclGroup : Decl {...};

stages/boot/ast.hpp:1435

`ast::DeclGuide`

stages/boot/ast.hpp:1543

`ast::DeclLabel`

struct DeclLabel : Decl {...};

stages/boot/ast.hpp:1580

`ast::DeclModule`

struct DeclModule : Decl {...};

stages/boot/ast.hpp:1571

`ast::DeclName`

struct DeclName : Decl {...};

stages/boot/ast.hpp:1415

`ast::DeclNspace`

struct DeclNspace : Decl {...};

stages/boot/ast.hpp:3336

`ast::DeclType`

struct DeclType : Decl {...};

stages/boot/ast.hpp:1392

`ast::DeclUse`

stages/boot/ast.hpp:1562

`ast::Expr`

struct Expr : Node {...};

stages/boot/ast.hpp:1073

`ast::ExprAddress`

struct ExprAddress : ExprUnary {...};

stages/boot/ast.hpp:2354

`ast::ExprAlignof`

struct ExprAlignof : Expr {...};

stages/boot/ast.hpp:2241

`ast::ExprAny`

struct ExprAny : Expr {...};

stages/boot/ast.hpp:2638

`ast::ExprAwait`

struct ExprAwait : Expr {...};

stages/boot/ast.hpp:2676

`ast::ExprBinary`

struct ExprBinary : Expr {...};

stages/boot/ast.hpp:2443

`ast::ExprBinaryCompiletime`

struct ExprBinaryCompiletime : Expr {...};

stages/boot/ast.hpp:2463

`ast::ExprBind`

struct ExprBind : Expr {...};

stages/boot/ast.hpp:2519

`ast::ExprBlock`

struct ExprBlock : Expr {...};

stages/boot/ast.hpp:2556

`ast::ExprCall`

struct ExprCall : Expr {...};

stages/boot/ast.hpp:2150

`ast::ExprCast`

struct ExprCast : Expr {...};

stages/boot/ast.hpp:2199

`ast::ExprCtor`

struct ExprCtor : Expr {...};

stages/boot/ast.hpp:2165

`ast::ExprDelete`

struct ExprDelete : Expr {...};

stages/boot/ast.hpp:2105

`ast::ExprDeleteArray`

struct ExprDeleteArray : Expr {...};

stages/boot/ast.hpp:2120

`ast::ExprDereference`

struct ExprDereference : Expr {...};

stages/boot/ast.hpp:2387

`ast::ExprDtor`

struct ExprDtor : Expr {...};

stages/boot/ast.hpp:2184

`ast::ExprFold`

struct ExprFold : Expr {...};

stages/boot/ast.hpp:2062

`ast::ExprForeign`

struct ExprForeign : Expr {...};

stages/boot/ast.hpp:3330

`ast::ExprForward`

struct ExprForward : Expr {...};

stages/boot/ast.hpp:2621

`ast::ExprGet`

struct ExprGet : Expr {...};

stages/boot/ast.hpp:2657

`ast::ExprGroup`

struct ExprGroup : Expr {...};

stages/boot/ast.hpp:1901

`ast::ExprIf`

struct ExprIf : Expr {...};

stages/boot/ast.hpp:2574

`ast::ExprIfBind`

struct ExprIfBind : Expr {...};

stages/boot/ast.hpp:2372

`ast::ExprIfTrue`

struct ExprIfTrue : Expr {...};

stages/boot/ast.hpp:2363

`ast::ExprIndex`

struct ExprIndex : Expr {...};

stages/boot/ast.hpp:2339

`ast::ExprInitList`

struct ExprInitList : Expr {...};

stages/boot/ast.hpp:2305

`ast::ExprInitMember`

this class is currently not used ¶

struct ExprInitMember : Expr {...};

stages/boot/ast.hpp:2288

`ast::ExprInitType`

struct ExprInitType : Expr {...};

stages/boot/ast.hpp:2271

`ast::ExprLambda`

struct ExprLambda : Expr {...};

stages/boot/ast.hpp:2485

`ast::ExprLiteral`

struct ExprLiteral : Expr {...};

stages/boot/ast.hpp:2539

`ast::ExprMember`

struct ExprMember : Expr {...};

stages/boot/ast.hpp:2396

`ast::ExprMemberAddress`

struct ExprMemberAddress : Expr {...};

stages/boot/ast.hpp:2411

`ast::ExprMemberDereference`

struct ExprMemberDereference : Expr {...};

stages/boot/ast.hpp:2428

`ast::ExprMove`

struct ExprMove : Expr {...};

stages/boot/ast.hpp:2607

`ast::ExprNew`

struct ExprNew : Expr {...};

stages/boot/ast.hpp:2084

`ast::ExprPath`

struct ExprPath : Expr {...};

stages/boot/ast.hpp:2026

`ast::ExprPlaceholder`

struct ExprPlaceholder : Expr {...};

stages/boot/ast.hpp:2691

`ast::ExprRange`

struct ExprRange : Expr {...};

stages/boot/ast.hpp:2045

`ast::ExprSelectBase`

struct ExprSelectBase : Expr { ... };

stages/boot/ast.hpp:2135

`ast::ExprSizeof`

struct ExprSizeof : Expr {...};

stages/boot/ast.hpp:2221

`ast::ExprSwitch`

struct ExprSwitch : Expr {...};

stages/boot/ast.hpp:2592

`ast::ExprTypeid`

struct ExprTypeid : Expr {...};

stages/boot/ast.hpp:2256

`ast::ExprUnary`

struct ExprUnary : Expr {...};

stages/boot/ast.hpp:2322

`ast::ExprsByBase`

struct ExprsByBase : ExprsByPos {...};

stages/boot/ast.hpp:2015

`ast::ExprsByEnum`

struct ExprsByEnum : ExprsByName {...};

stages/boot/ast.hpp:1988

`ast::ExprsById`

struct ExprsById : ExprsByName {...};

stages/boot/ast.hpp:1966

`ast::ExprsByIndex`

struct ExprsByIndex : ExprGroup {...};

stages/boot/ast.hpp:1997

`ast::ExprsByMember`

struct ExprsByMember : ExprsByName {...};

stages/boot/ast.hpp:1979

`ast::ExprsByName`

struct ExprsByName : ExprGroup {...};

stages/boot/ast.hpp:1953

`ast::ExprsByPos`

struct ExprsByPos : ExprGroup {...};

stages/boot/ast.hpp:1937

`ast::File`

struct File {...};

stages/boot/ast.hpp:3555

`ast::Flow`

struct Flow : Node {...};

stages/boot/ast.hpp:3047

`ast::FlowBreak`

struct FlowBreak : Flow {...};

stages/boot/ast.hpp:3232

`ast::FlowCatch`

struct FlowCatch : Flow {...};

stages/boot/ast.hpp:3277

`ast::FlowContinue`

struct FlowContinue : Flow {...};

stages/boot/ast.hpp:3225

`ast::FlowGoto`

struct FlowGoto : Flow {...};

stages/boot/ast.hpp:3239

`ast::FlowIf`

struct FlowIf : Flow {...};

stages/boot/ast.hpp:3126

`ast::FlowLoop`

struct FlowLoop : Flow {...};

stages/boot/ast.hpp:3176

`ast::FlowRange`

struct FlowRange : Flow {...};

stages/boot/ast.hpp:3202

`ast::FlowReturn`

struct FlowReturn : Flow {...};

stages/boot/ast.hpp:3094

`ast::FlowSwitch`

struct FlowSwitch : Flow {...};

stages/boot/ast.hpp:3254

`ast::FlowThrow`

struct FlowThrow : Flow {...};

stages/boot/ast.hpp:3315

`ast::FlowTry`

struct FlowTry : Flow {...};

stages/boot/ast.hpp:3297

`ast::FlowYield`

struct FlowYield : Flow {...};

stages/boot/ast.hpp:3110

`ast::Node`

struct Node {...};

stages/boot/ast.hpp:705

`ast::Pattern`

struct Pattern : Node {...};

stages/boot/ast.hpp:2738

`ast::PatternAnyType`

struct PatternAnyType : Pattern {...};

stages/boot/ast.hpp:2908

`ast::PatternBinding`

struct PatternBinding : Pattern {...};

stages/boot/ast.hpp:3030

`ast::PatternConcept`

struct PatternConcept : Pattern {...};

stages/boot/ast.hpp:2968

`ast::PatternDereference`

struct PatternDereference : Pattern {...};

stages/boot/ast.hpp:2864

`ast::PatternDynType`

struct PatternDynType : Pattern {...};

stages/boot/ast.hpp:2923

`ast::PatternExpr`

struct PatternExpr : Pattern {...};

stages/boot/ast.hpp:2834

`ast::PatternExtractor`

struct PatternExtractor : Pattern {...};

stages/boot/ast.hpp:2849

`ast::PatternIfTrue`

struct PatternIfTrue : Pattern {...};

stages/boot/ast.hpp:2871

`ast::PatternMember`

struct PatternMember : Pattern {...};

stages/boot/ast.hpp:2983

`ast::PatternMembers`

struct PatternMembers : Pattern {...};

stages/boot/ast.hpp:2999

`ast::PatternOr`

struct PatternOr : Pattern {...};

stages/boot/ast.hpp:2802

`ast::PatternRange`

struct PatternRange : Pattern {...};

stages/boot/ast.hpp:2817

`ast::PatternSwitch`

struct PatternSwitch : Pattern {...};

stages/boot/ast.hpp:3015

`ast::PatternTaggedUnion`

struct PatternTaggedUnion : Pattern {...};

stages/boot/ast.hpp:2938

`ast::PatternType`

struct PatternType : Pattern {...};

stages/boot/ast.hpp:2953

`ast::PatternVariantByExpr`

struct PatternVariantByExpr : Pattern {...};

stages/boot/ast.hpp:2893

`ast::PatternVariantByType`

struct PatternVariantByType : Pattern {...};

stages/boot/ast.hpp:2878

`ast::Scope`

struct Scope {...};

stages/boot/ast.hpp:1271

`ast::Token`

struct Token {...};

stages/boot/ast.hpp:363

`ast::TokenBuffer`

struct TokenBuffer : Token {...};

stages/boot/ast.hpp:693

`ast::TokenLiteral`

struct TokenLiteral : Token {...};

stages/boot/ast.hpp:652

`ast::Type`

struct Type : Node {...};

stages/boot/ast.hpp:1187

`ast::TypeArray`

struct TypeArray : TypeQualifier {...};

stages/boot/ast.hpp:1766

`ast::TypeAuto`

struct TypeAuto : Type {...};

stages/boot/ast.hpp:1619

`ast::TypeDecay`

struct TypeDecay : TypeQualifier {...};

stages/boot/ast.hpp:1829

`ast::TypeDirection`

struct TypeDirection : TypeQualifier {...};

stages/boot/ast.hpp:1693

`ast::TypeEnum`

struct TypeEnum : Type {...};

stages/boot/ast.hpp:1869

`ast::TypeExpr`

struct TypeExpr : Type {...};

stages/boot/ast.hpp:1851

`ast::TypeFunc`

struct TypeFunc : Type {...};

stages/boot/ast.hpp:1472

`ast::TypeLifetime`

struct TypeLifetime : TypeQualifier {...};

stages/boot/ast.hpp:1836

`ast::TypeLong`

struct TypeLong : TypeQualifier {...};

stages/boot/ast.hpp:1725

`ast::TypeModifierSize`

struct TypeModifierSize : Type {...};

stages/boot/ast.hpp:1892

`ast::TypeMovable`

struct TypeMovable : TypeQualifier {...};

stages/boot/ast.hpp:1819

`ast::TypeMutable`

struct TypeMutable : TypeQualifier {...};

stages/boot/ast.hpp:1705

`ast::TypePartial`

struct TypePartial : TypeQualifier {...};

stages/boot/ast.hpp:1715

`ast::TypePath`

struct TypePath : Type {...};

stages/boot/ast.hpp:1659

`ast::TypePointer`

struct TypePointer : TypeQualifier {...};

stages/boot/ast.hpp:1783

`ast::TypePointerMember`

struct TypePointerMember : TypePointer {...};

stages/boot/ast.hpp:1793

`ast::TypePrimitive`

struct TypePrimitive : Type {...};

stages/boot/ast.hpp:1637

`ast::TypeQualifier`

struct TypeQualifier : Type {...};

stages/boot/ast.hpp:1678

`ast::TypeReference`

struct TypeReference : TypeQualifier {...};

stages/boot/ast.hpp:1808

`ast::TypeSigned`

struct TypeSigned : TypeQualifier {...};

stages/boot/ast.hpp:1735

`ast::TypeStruct`

struct TypeStruct : Type {...};

stages/boot/ast.hpp:3482

`ast::TypeUnsigned`

struct TypeUnsigned : TypeQualifier {...};

stages/boot/ast.hpp:1745

`ast::TypeVoid`

struct TypeVoid : Type {...};

stages/boot/ast.hpp:1628

`ast::TypeVolatile`

struct TypeVolatile : TypeQualifier {...};

stages/boot/ast.hpp:1755

`ast::Visitor`

Base class to create AST visitors. ¶

struct Visitor {...};

stages/boot/ast.hpp:124

`ast::Visitor::visit`

Methods to reimplement to visit specific kinds of AST nodes. ¶

stages/boot/ast.hpp:127

virtual void visit(Node *, AttrPtr &n) {}

stages/boot/ast.hpp:167

virtual void visit(Node *, BlockPtr &n);

stages/boot/ast.hpp:171

virtual void visit(Node *, DeclPtr &n);

stages/boot/ast.hpp:173

virtual void visit(Node *, ExprPtr &n);

stages/boot/ast.hpp:170

virtual void visit(FilePtr &);

stages/boot/ast.hpp:166

virtual void visit(Node *, FlowPtr &n);

stages/boot/ast.hpp:174

virtual void visit(Node *, IdPtr &n) {}

stages/boot/ast.hpp:169

void visit(Node*, NodePtr &);

stages/boot/ast.hpp:127

This method is not meant to be overridden. ¶

virtual void visit(Node *, PatternPtr &n);

stages/boot/ast.hpp:175

virtual void visit(Node *, TokenPtr &n);

stages/boot/ast.hpp:168

virtual void visit(Node *, TypePtr &n);

stages/boot/ast.hpp:172

`ast::id`

struct Id : Node {...};

stages/boot/ast.hpp:868

Appendix B: Bootstrap C++ translator

Appendix C: Grammar rules

`access`

stages/boot/cigma.ypp:1785

: PUBLIC
| PROTECTED
| PRIVATE
;

`access_opt`

stages/boot/cigma.ypp:1795

: access
| nothing
;

`attr`

stages/boot/cigma.ypp:1638

: "@" "{" attrs_path list_end "}"
| "@" nspace_path "{" attrs_path list_end "}"
;

`attr_ids`

stages/boot/cigma.ypp:1589

: ID
| nspace_path "@" ID
;

`attr_path`

stages/boot/cigma.ypp:1610

: attr_ids template_args_opt
;

`attrs`

stages/boot/cigma.ypp:1669

: attrs attr
| attr
;

`attrs_opt`

stages/boot/cigma.ypp:1686

: attrs
| nothing
;

`attrs_path`

stages/boot/cigma.ypp:1620

: attrs_path list_sep attr_path
| attr_path
;

`block`

stages/boot/cigma.ypp:3302

: "{" statements list_end "}"
| "{" "}"
| "{" "?" "}"
;

`block_opt`

stages/boot/cigma.ypp:3336

: block
| access block
| KW_FOREIGN
| nothing
;

`cigma`

stages/boot/cigma.ypp:912

: decls_global list_end
| attrs ";" decls_global list_end
;

`concept_id`

stages/boot/cigma.ypp:1006

: "::" ID
;

`concept_path`

stages/boot/cigma.ypp:1714

: "::" concept_suffix template_args_opt
;

`concept_path_opt`

stages/boot/cigma.ypp:1727

: concept_path
| nothing
;

`concept_suffix`

stages/boot/cigma.ypp:1696

: ID
| nspace_path concept_id
;

`constraint`

stages/boot/cigma.ypp:3121

[1] Named constraint specialization ¶

[2] Compile-time expression constraint (must evaluate to true) ¶

`constraint_statement`

stages/boot/cigma.ypp:3240

: expr
| type_noauto
| constraint
;

`constraint_statements`

stages/boot/cigma.ypp:3221

: constraint_statements list_sep constraint_statement
| constraint_statement
;

`constraints`

stages/boot/cigma.ypp:3067

: constraints "&&" constraint
| constraints "||" constraint
| constraint
;

`constraints_opt`

stages/boot/cigma.ypp:3111

: constraints
| nothing
;

`coro_return_type`

stages/boot/cigma.ypp:3566

: "=>" type_novariadic
| "=>" ^[1]
;

[1] "void" return type ¶

`ctor_path`

stages/boot/cigma.ypp:1305

: "<"
| member_prefix "." "<"
;

`decl_bind`

stages/boot/cigma.ypp:2682

: "{" decl_names list_end "}" type_auto expr_init ^[1]
;

[1] structured binding ¶

`decl_constraint_args_opt`

stages/boot/cigma.ypp:3202

: "[" decl_proc_args list_end "]"
| nothing
;

`decl_dtor`

stages/boot/cigma.ypp:2957

: dtor_path ":" "(" ")" attrs_opt
;

`decl_group`

stages/boot/cigma.ypp:2702

: decl_vars
| decl_names type constraints_opt attrs_opt access_opt block expr_init_opt
;

`decl_guide`

stages/boot/cigma.ypp:2973

: ctor_path ":" "(" decl_proc_args_opt ")" "->" type_path
;

`decl_init`

stages/boot/cigma.ypp:2754

: decl_vars
| decl_bind
;

`decl_list`

stages/boot/cigma.ypp:2309

: decl_list list_sep decl
| decl
;

`decl_name`

stages/boot/cigma.ypp:2549

: name_path
| NOID
| name_path lifetime_id
;

`decl_names`

stages/boot/cigma.ypp:2573

`decl_oper`

stages/boot/cigma.ypp:2833

: overload_path type attrs_opt
| specop_path type_or_void attrs_opt
;

`decl_proc_arg`

stages/boot/cigma.ypp:3710

: decl_names type_arg constraints_opt attrs_opt
| decl_names type_arg constraints_opt attrs_opt expr_init
;

`decl_proc_args`

stages/boot/cigma.ypp:3744

: decl_proc_args list_sep decl_proc_arg
| decl_proc_args list_sep ".."
| ".."
| decl_proc_arg
;

`decl_proc_args_opt`

stages/boot/cigma.ypp:3787

: decl_proc_args list_end
| nothing
;

`decl_template_arg`

stages/boot/cigma.ypp:3905

[1] anonymous type ¶

[2] anonymous default argument ¶

`decl_template_arg_variadic_type`

stages/boot/cigma.ypp:3872

: type_id ".." concept_path_opt
| ":" NOID ".." concept_path_opt
;

`decl_template_args`

stages/boot/cigma.ypp:3803

: "[" decl_template_args_body list_end "]"
| "[" list_end "]" ^[1]
;

[1] fully specialized templates have nothing here ¶

`decl_template_args_body`

stages/boot/cigma.ypp:3853

: decl_template_args_body list_sep decl_template_arg
| decl_template_arg
;

`decl_template_args_opt`

stages/boot/cigma.ypp:3838

: decl_template_args
| nothing
;

`decl_top`

stages/boot/cigma.ypp:2368

: decl
| decl_use_module
| decl_use_header
| decl_module
;

`decl_type`

stages/boot/cigma.ypp:2762

[1] Unscoped enum ¶

[2] Scoped enum ¶

[3] Union ¶

[4] Typeclass ¶

`decl_var`

stages/boot/cigma.ypp:2630

: decl_name type constraints_opt attrs_opt expr_init_opt
;

`decl_vars`

stages/boot/cigma.ypp:2648

: decl_names type constraints_opt attrs_opt
| decl_names type constraints_opt attrs_opt expr_init
;

`decls`

stages/boot/cigma.ypp:2328

: decl_list list_end
;

`decls_global`

stages/boot/cigma.ypp:2349

: decls_global list_sep decl_top
| decl_top
;

`decls_opt`

stages/boot/cigma.ypp:2339

: decls
| nothing
;

`dtor_path`

stages/boot/cigma.ypp:1326

: ">"
| member_prefix "." ">"
;

`expr_args`

stages/boot/cigma.ypp:4201

: expr_paren
| "(" ")"
;

`expr_args_compiletime`

stages/boot/cigma.ypp:4215

: expr_compiletime
| "[" "]"
;

`expr_block`

stages/boot/cigma.ypp:4386

: "(" block ")"
;

`expr_delete`

stages/boot/cigma.ypp:4445

: DELETE expr_primary
| DELETE "." "(" ")" expr_primary
;

Access to tagged union member (not yet implemented) ¶ ::std::get_if<$expr>(& $expr_postfix) ¶ ::std::get_if<$type>(& $expr_postfix) ¶ get<$expr>($expr_postfix) ¶ get<$type>($expr_postfix) ¶ std::any_cast<$type>(& $expr) ¶ std::any_cast<$type>($expr) ¶ dynamic_cast<$type>($expr) ¶ conditional expression ¶ bind subexpression to a local name ¶ std::bind ¶ std::bind_front ¶ /std/placeholders _N ¶ Define lambda and call it in place ¶ Compile-time version of the above ¶ dynamic_cast ¶ static_cast ¶ /std:is_same[:A, :B] value ¶ !/std:is_same[:A, :B] value ¶ Used as don’t care element in /std tie ¶ Used as don’t care element in /std tie ¶ Simplified if ¶ Simplified else ¶ Simplified else if ¶ Simplified switch ¶ Match range ¶ Match range ¶ Match expression ¶ Match via extractor ¶ Dereference previous match ¶ Match if convertible to true ¶ Match variant by type ¶ Match variant by index ¶ Match via any_cast ¶ Match via dynamic_cast ¶ Match tagged union member ¶ Match members by name ¶ Match name ¶ Match anything ¶ Nested switch ¶ Bind to local variable ¶ Structured binding ¶ Capture by-copy by default ¶ Capture by-reference by default ¶ Capture by-copy ¶ Capture by-copy of pack expansion ¶ Capture by-copy with initializer ¶ Capture by-reference ¶ Capture by-reference of pack expansion ¶ Capture by-reference with initializer ¶ Capture by-copy of current object ¶ Capture by-reference of current object ¶ designated initialization ¶ in-place initialization ¶