Ada with Alire and GNAT 16: install and build

A new Ada program that Alire builds is compiled with 31 GNAT switches, most of the compiler’s optional warnings, its validity checks and 22 style checks among them, and still not one assertion is checked: that takes another build profile. Alire 2.1.1 is the package and toolchain manager of Ada, and GNAT 16.1.0 is the compiler of every example in this mini-course, here on a Mac with Apple silicon; both are released for Linux and Windows too.

Here you install Alire, choose the compiler and build a first program. You read the files a new crate is made of, compare what the three build profiles switch on, fix the messages the default profile reports, switch a crate to Ada 2022, and see where Ada is used and what its licence asks of the programs you build.

Alire installs the compiler, then one command builds the crate

Alire publishes its command, alr, as a zip for each platform on its releases page, and for a Mac with Apple silicon it is alr-2.1.1-bin-aarch64-macos.zip. You put its bin folder on your PATH, and alr then installs everything else itself: the GNAT compiler and GPRbuild, the tool that drives it, come as cratescrate: In Alire, a folder with an alire.toml manifest: a program or library with a name, a version and its dependencies, built with alr build. The compiler and GPRbuild are crates too. of Alire’s community index, downloaded into Alire’s own folder rather than into the system. The Alire documentation says the first alr run offers to choose a toolchain for you; alr toolchain --select makes the choice explicit, which is how you pin a version. Step through the whole path, with the two checks that can send you back:

The recorded session starts with Alire installed and alr toolchain --select gnat_native=16.1.0 gprbuild=26.0.1 already run. Its new crate holds an empty main program, which the session replaces with this one; the package GNAT.Compiler_Version reports which compiler built it:

with Ada.Text_IO;
with GNAT.Compiler_Version;

procedure Hello is
   package Compiler is new GNAT.Compiler_Version;
begin
   Ada.Text_IO.Put_Line ("Hello from Ada");
   Ada.Text_IO.Put_Line ("Compiled by GNAT " & Compiler.Version);
   Ada.Text_IO.Put_Line ("Integer'Last =" & Integer'Last'Image);
end Hello;

from session import run

# The first session of the Ada mini-course, with Alire 2.1.1 installed and its toolchain selected: the versions,
# a new crate made by alr init, the files it wrote, a first build and run, the switches the build used, and the
# compiler's own version. hello.adb replaces the empty main program that alr init writes.
run("""
alr --version
alr toolchain
alr -n init --bin hello
cd hello
find . -type f -not -path './alire/*' | sort
cat src/hello.adb
cp ../hello.adb src/hello.adb
alr build
alr run
grep -o '"-[^"]*"' config/hello_config.gpr | wc -l
alr exec -- gnat --version
""")

$ alr --version
alr 2.1.1
$ alr toolchain
CRATE       VERSION STATUS  NOTES
gprbuild    26.0.1  Default
gnat_native 16.1.0  Default
$ alr -n init --bin hello
Enter a short description of the crate: (default: '')
Using default: ''


Select a software license for the crate?
Using default choice in non-interactive mode: MIT OR Apache-2.0 WITH LLVM-exception
Warning: TRUE
Enter a comma (',') separated list of tags to help people find your crate: (default: '')
Using default: ''
Enter an optional Website URL for the crate: (default: '')
Using default: ''
Success: hello initialized successfully.
$ cd hello
$ find . -type f -not -path './alire/*' | sort
./.gitignore
./alire.toml
./config/hello_config.ads
./config/hello_config.gpr
./config/hello_config.h
./hello.gpr
./src/hello.adb
$ cat src/hello.adb
procedure Hello is
begin
   null;
end Hello;
$ cp ../hello.adb src/hello.adb
$ alr build
Note: Building hello=0.1.0-dev/hello.gpr...
Setup
   [mkdir]        object directory for project Hello
   [mkdir]        exec directory for project Hello
Compile
   [Ada]          hello.adb
Bind
   [gprbind]      hello.bexch
   [Ada]          hello.ali
Link
   [link]         hello.adb
Success: Build finished successfully in … seconds.
$ alr run
Note: Building hello=0.1.0-dev/hello.gpr...
gprbuild: "hello" up to date
Success: Build finished successfully in … seconds.
Hello from Ada
Compiled by GNAT 16.1.0
Integer'Last = 2147483647
$ grep -o '"-[^"]*"' config/hello_config.gpr | wc -l
      31
$ alr exec -- gnat --version
GNAT 16.1.0
Copyright (C) 1996-2025, Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Read it from the top. alr toolchain lists the two tools the crate builds with, gnat_native 16.1.0 and gprbuild 26.0.1, both marked Default. alr -n init --bin hello makes the crate: -n answers every question with its default, so the description and website stay empty and the licence becomes MIT OR Apache-2.0 WITH LLVM-exception, which you can change later. The odd line Warning: TRUE comes from alr’s own prompt library, which prints whether its output is a terminal when it answers a choice for you; it changes nothing.

The build runs in four phases: Setup makes the object and program folders, Compile runs GNAT on hello.adb, Bind checks that all units fit together and writes their start-up code, and Link makes the program. alr run rebuilds only if a file changed, and starts it. The program printed what built it, GNAT 16.1.0, and Integer'Last with a space in front of 2147483647: the attribute 'Image gives a non-negative number a leading space, a rule lesson 2 comes back to. alr exec -- gnat --version runs a command with the crate’s toolchain on the PATH.

alire.toml describes the crate, and alr writes the switches

A crate is a folder with a manifest, alire.toml, that names it and the programs it builds. Beside it, alr init wrote hello.gpr, a GPR project fileGPR project file: A .gpr file read by GPRbuild: the source folders, the main programs, the folders for objects and programs, and the compiler switches of an Ada build.: where the sources are, which file is the main program, and where objects and programs go. The third file below was not written by alr init but by alr build:

name = "hello"
description = ""
version = "0.1.0-dev"

authors = ["Learner"]
maintainers = ["Learner <learner@example.com>"]
maintainers-logins = ["learner"]
licenses = "MIT OR Apache-2.0 WITH LLVM-exception"
website = ""
tags = []

executables = ["hello"]

with "config/hello_config.gpr";
project Hello is

   for Source_Dirs use ("src/", "config/");
   for Object_Dir use "obj/" & Hello_Config.Build_Profile;
   for Create_Missing_Dirs use "True";
   for Exec_Dir use "bin";
   for Main use ("hello.adb");

   package Compiler is
      for Default_Switches ("Ada") use Hello_Config.Ada_Compiler_Switches;
   end Compiler;

   package Binder is
      for Switches ("Ada") use ("-Es"); --  Symbolic traceback
   end Binder;

   package Install is
      for Artifacts (".") use ("share");
   end Install;

end Hello;

--  Configuration for hello generated by Alire
abstract project Hello_Config is
   Crate_Version := "0.1.0-dev";
   Crate_Name := "hello";

   Alire_Host_OS := "macos";

   Alire_Host_Arch := "aarch64";

   Alire_Host_Distro := "distribution_unknown";
   Ada_Compiler_Switches := External_As_List ("ADAFLAGS", " ");
   Ada_Compiler_Switches := Ada_Compiler_Switches &
          (
            "-Og" -- Optimize for debug
           ,"-ffunction-sections" -- Separate ELF section for each function
           ,"-fdata-sections" -- Separate ELF section for each variable
           ,"-g" -- Generate debug info
           ,"-gnatwa" -- Enable all warnings
           ,"-gnatw.X" -- Disable warnings for No_Exception_Propagation
           ,"-gnatVa" -- All validity checks
           ,"-gnaty3" -- Specify indentation level of 3
           ,"-gnatya" -- Check attribute casing
           ,"-gnatyA" -- Use of array index numbers in array attributes
           ,"-gnatyB" -- Check Boolean operators
           ,"-gnatyb" -- Blanks not allowed at statement end
           ,"-gnatyc" -- Check comments
           ,"-gnaty-d" -- Disable check no DOS line terminators present
           ,"-gnatye" -- Check end/exit labels
           ,"-gnatyf" -- No form feeds or vertical tabs
           ,"-gnatyh" -- No horizontal tabs
           ,"-gnatyi" -- Check if-then layout
           ,"-gnatyI" -- check mode IN keywords
           ,"-gnatyk" -- Check keyword casing
           ,"-gnatyl" -- Check layout
           ,"-gnatym" -- Check maximum line length
           ,"-gnatyn" -- Check casing of entities in Standard
           ,"-gnatyO" -- Check that overriding subprograms are explicitly marked as such
           ,"-gnatyp" -- Check pragma casing
           ,"-gnatyr" -- Check identifier references casing
           ,"-gnatyS" -- Check no statements after THEN/ELSE
           ,"-gnatyt" -- Check token spacing
           ,"-gnatyu" -- Check unnecessary blank lines
           ,"-gnatyx" -- Check extra parentheses
           ,"-gnatW8" -- UTF-8 encoding for wide characters
          );

   type Build_Profile_Kind is ("release", "validation", "development");
   Build_Profile : Build_Profile_Kind := "development";

end Hello_Config;

The project file’s first line, with "config/hello_config.gpr";, pulls in the generated file, and its Compiler package uses that file’s Ada_Compiler_Switches, so the switches never live in hello.gpr itself. The object folder is obj/ plus the profile’s name, obj/development here, which keeps the objects of different profiles apart. Step through one build and watch who reads what:

Two habits follow from it. Change the crate in alire.toml and hello.gpr, never in config/, because alr build writes that folder again every time; the .gitignore that alr init wrote already keeps config/, obj/, bin/ and alire/ out of version control. And add libraries with alr with <crate>, which records the dependency in alire.toml and the exact versions it chose in alire/alire.lock.

The build profile decides which checks the compiler runs

Alire has three build profilesbuild profile: One of Alire's three named sets of compiler switches for a crate: development (the default), validation or release, chosen with alr build --validation or --release., and its documentation says the crate you are working on builds in development unless you ask for another one, while its dependencies build in release. alr build --validation and alr build --release choose the others. This session builds the same new crate with both and prints the switches each build used:

from session import run

# The same new crate built with the two other build profiles: alr writes the switches of the profile into
# config/hello_config.gpr before it calls GPRbuild, so each list below is what that build compiled with.
run("""
alr -n init --bin hello
cd hello
alr build --validation
grep -o '"-[^"]*"' config/hello_config.gpr | tr '\\n' ' '
alr build --release
grep -o '"-[^"]*"' config/hello_config.gpr | tr '\\n' ' '
""")

$ alr -n init --bin hello
Enter a short description of the crate: (default: '')
Using default: ''


Select a software license for the crate?
Using default choice in non-interactive mode: MIT OR Apache-2.0 WITH LLVM-exception
Warning: TRUE
Enter a comma (',') separated list of tags to help people find your crate: (default: '')
Using default: ''
Enter an optional Website URL for the crate: (default: '')
Using default: ''
Success: hello initialized successfully.
$ cd hello
$ alr build --validation
Note: Building hello=0.1.0-dev/hello.gpr...
Setup
   [mkdir]        object directory for project Hello
   [mkdir]        exec directory for project Hello
Compile
   [Ada]          hello.adb
Bind
   [gprbind]      hello.bexch
   [Ada]          hello.ali
Link
   [link]         hello.adb
Success: Build finished successfully in … seconds.
$ grep -o '"-[^"]*"' config/hello_config.gpr | tr '\n' ' '
"-O3" "-gnatn" "-ffunction-sections" "-fdata-sections" "-g" "-gnato" "-gnatwa" "-gnatw.X" "-gnatVa" "-gnatwe" "-gnata" "-gnaty3" "-gnatya" "-gnatyA" "-gnatyB" "-gnatyb" "-gnatyc" "-gnaty-d" "-gnatye" "-gnatyf" "-gnatyh" "-gnatyi" "-gnatyI" "-gnatyk" "-gnatyl" "-gnatym" "-gnatyn" "-gnatyO" "-gnatyp" "-gnatyr" "-gnatyS" "-gnatyt" "-gnatyu" "-gnatyx" "-gnatW8"
$ alr build --release
Note: Building hello=0.1.0-dev/hello.gpr...
Setup
   [mkdir]        object directory for project Hello
Compile
   [Ada]          hello.adb
Bind
   [gprbind]      hello.bexch
   [Ada]          hello.ali
Link
   [link]         hello.adb
Success: Build finished successfully in … seconds.
$ grep -o '"-[^"]*"' config/hello_config.gpr | tr '\n' ' '
"-O3" "-gnatn" "-ffunction-sections" "-fdata-sections" "-gnatW8"

Side by side, with the 31 switches of the first session:

Two rows matter most for the rest of the mini-course. Only validation has -gnata, which the GNAT User’s Guide says enables assertions, preconditions, postconditions, type invariants and predicates, all disabled by default; the contracts of lesson 3 are ignored by every other build. And only validation has -gnatwe, so a warning that the development build merely prints stops a validation build. Validation also adds -gnato explicitly, though the User’s Guide says overflow checking is already on when no -gnato is given, as lesson 2’s overflow shows.

A style message is only a warning until validation makes it an error

GNAT’s style checksstyle check: A GNAT check, switched on with -gnaty, of how code is written rather than what it does, such as casing, line length or and then in conditions. It reports a (style) message. look at how code is written, not what it does. Here is a first draft of a small program that accepts a payment of up to 100,000 paise. It works, and it has four slips:

with Ada.Command_Line; use Ada.Command_Line;
with Ada.Text_IO;      use Ada.Text_IO;

procedure Limits is
   Amount : constant Integer := Integer'Value (Argument (1));
   Spare  : Integer := 0;
begin
   if Amount >= 0 and Amount <= 100_000 then
      put_line ("Paid:" & Amount'Image & " paise, within the limit of 100000 paise");
   end if;
end Limits;

The development build reports them and still links the program:

from session import run

# limits.adb as a first draft often looks: it builds with the development profile, which reports every warning and
# style message and still links the program.
run("""
cd limits
alr build
./bin/limits 1205
""")

$ cd limits
$ alr build
Note: Synchronizing workspace...
Nothing to update.

Note: Building limits=0.1.0-dev/limits.gpr...
Setup
   [mkdir]        object directory for project Limits
   [mkdir]        exec directory for project Limits
Compile
   [Ada]          limits.adb
limits.adb:6:04: warning: variable "Spare" is not referenced [-gnatwu]
limits.adb:8:19: (style) "and then" required [-gnatyB]
limits.adb:9:07: (style) bad casing of "Put_Line" declared at a-textio.ads:565 [-gnatyr]
limits.adb:9:80: (style) this line is too long: 85 [-gnatyM]
Bind
   [gprbind]      limits.bexch
   [Ada]          limits.ali
Link
   [link]         limits.adb
Success: Build finished successfully in … seconds.
$ ./bin/limits 1205
Paid: 1205 paise, within the limit of 100000 paise

Each message names its place, line and column, and ends with the switch that produced it. The warning variable "Spare" is not referenced comes from -gnatwu, part of -gnatwa. The three (style) messages come from the -gnaty checks: "and then" required because the User’s Guide’s rule -gnatyB permits and and or only for modular or array operands and simple Boolean variables or constants, so a condition built from comparisons needs the short-circuit formAda's short-circuit forms: and then evaluates its right side only when the left side is True, or else only when it is False, so the right side may rely on the left.; bad casing of "Put_Line" because -gnatyr wants every use of a name spelt as it was declared, here at line 565 of a-textio.ads, the specification of Ada.Text_IO; and this line is too long: 85 because -gnatym allows 79 characters, a check the message tags with -gnatyM, the switch that sets another length. The same draft with the validation profile, then the fixed file:

from session import run

# The same draft with the validation profile, which treats warnings and style messages as errors; then the fixed
# file from limits-fixed, built the same way.
run("""
cd limits
!alr build --validation
cp ../limits-fixed/limits.adb src/limits.adb
alr build --validation
./bin/limits 1205
""")

$ cd limits
$ alr build --validation
Note: Synchronizing workspace...
Nothing to update.

Note: Building limits=0.1.0-dev/limits.gpr...
Setup
   [mkdir]        object directory for project Limits
   [mkdir]        exec directory for project Limits
Compile
   [Ada]          limits.adb
limits.adb:6:04: warning: variable "Spare" is not referenced [-gnatwu]
limits.adb:8:19: (style) "and then" required [-gnatyB]
limits.adb:9:07: (style) bad casing of "Put_Line" declared at a-textio.ads:565 [-gnatyr]
limits.adb:9:80: (style) this line is too long: 85 [-gnatyM]

   compilation of limits.adb failed

gprbuild: *** compilation phase failed
ERROR: Command ["gprbuild", "-s", "-j0", "-p", "-P", "limits/limits.gpr"] exited with code 4
ERROR: Compilation failed.
[exit status 1]
$ cp ../limits-fixed/limits.adb src/limits.adb
$ alr build --validation
Note: Building limits=0.1.0-dev/limits.gpr...
Compile
   [Ada]          limits.adb
Bind
   [gprbind]      limits.bexch
   [Ada]          limits.ali
Link
   [link]         limits.adb
Success: Build finished successfully in … seconds.
$ ./bin/limits 1205
Paid: 1205 paise, within the limit of 100000 paise

Under validation the very same four messages stopped the build, because -gnatwe counts them as errors: compilation of limits.adb failed, exit status 1 from alr. The fixed file removed the unused variable, wrote and then, used the declared casing and split the long line, and it built with no message at all.

GNAT 16 compiles Ada 2012 until a crate asks for Ada 2022

The GNAT User’s Guide says the compiler’s default mode is Ada 2012, and GNAT 16.1.0 still keeps to it: forms that are new in Ada 2022, such as the two below, do not compile until a switch asks for that edition. This program counts the passes in a class with an aggregate in square brackets and @, which stands for the target of an assignment:

with Ada.Text_IO; use Ada.Text_IO;

procedure Brackets is
   type Marks is array (1 .. 4) of Natural;
   Class  : constant Marks := [72, 95, 38, 48];
   Passed : Natural := 0;
begin
   for Mark of Class loop
      if Mark >= 40 then
         Passed := @ + 1;
      end if;
   end loop;
   Put_Line ("Passed:" & Passed'Image & " of" & Class'Length'Image);
end Brackets;

from session import run

# brackets.adb uses two Ada 2022 forms, a [ ] aggregate and @ for the target of an assignment. GNAT 16 compiles
# Ada 2012 unless a switch asks for 2022, so the first build stops; the second alire.toml asks for Ada 2022, and the
# switch it adds is then in the generated configuration.
run("""
cd brackets
!alr build
cp ../brackets-2022/alire.toml alire.toml
tail -2 alire.toml
alr build
grep -o '"-gnat2022"' config/brackets_config.gpr
./bin/brackets
""")

$ cd brackets
$ alr build
Note: Synchronizing workspace...
Nothing to update.

Note: Building brackets=0.1.0-dev/brackets.gpr...
Setup
   [mkdir]        object directory for project Brackets
   [mkdir]        exec directory for project Brackets
Compile
   [Ada]          brackets.adb
brackets.adb:5:31: error: illegal character, replaced by "("
brackets.adb:10:20: error: target name is an Ada 2022 feature
brackets.adb:10:20: error: unit must be compiled with -gnat2022 switch

   compilation of brackets.adb failed

gprbuild: *** compilation phase failed
ERROR: Command ["gprbuild", "-s", "-j0", "-p", "-P", "brackets/brackets.gpr"] exited with code 4
ERROR: Compilation failed.
[exit status 1]
$ cp ../brackets-2022/alire.toml alire.toml
$ tail -2 alire.toml
[build-switches]
"*".ada_version = "Ada2022"
$ alr build
Note: Synchronizing workspace...
Nothing to update.

Note: Building brackets=0.1.0-dev/brackets.gpr...
Compile
   [Ada]          brackets.adb
Bind
   [gprbind]      brackets.bexch
   [Ada]          brackets.ali
Link
   [link]         brackets.adb
Success: Build finished successfully in … seconds.
$ grep -o '"-gnat2022"' config/brackets_config.gpr
"-gnat2022"
$ ./bin/brackets
Passed: 3 of 4

The first build read [ as an illegal character and said outright that the target name @ is an Ada 2022 feature and the unit must be compiled with -gnat2022. Two lines in alire.toml fixed it: the [build-switches] table with "*".ada_version = "Ada2022", where * means every profile. Alire then adds -gnat2022 to the generated switches, and the program counted 3 passes of 4. Every crate in this mini-course carries those two lines.

Ada 2022 is the fourth edition of the standard, ISO/IEC 8652:2023, and the language specificationlanguage specification: The document that defines what a language means for every implementation, often an international standard, such as the Ada Reference Manual (ISO/IEC 8652:2023) or the C standard. More in “Reading language references and release notes” every example of this mini-course follows is its Reference Manual. Walk through the editions to see where the features of the coming lessons came from:

The Reference Manual marks its history in its paragraph numbers, which helps when you read it next to an older book: a number such as 8/3 changed in the Ada 2012 edition and 1/5 in Ada 2022, while an unmarked number is unchanged since 1995.

Where Ada is used, and what GNAT’s licence asks of your programs

Ada is a language for software that must keep working. AdaCore, which contributes to GNAT and makes the SPARK tools, lists the industries its tools serve as avionics, defence, automotive, rail, medical, space and security. Its SPARK User’s Guide describes SPARK as a language and a set of verification tools for high-assurance software, based on Ada with the features that defy verification removed, and names air-traffic management and avionics among the systems it suits; lesson 3 runs its prover on a small program. In the Stack Overflow Developer Survey 2025, about 1.4 % of all respondents and 3 % of those learning to code said they had done extensive development work in Ada in the past year. Those are small numbers next to C or Java, and they are why this mini-course spends its time on what makes Ada different rather than on syntax.

The licences are in the crates themselves. Alire’s index lists the gnat_native 16.1.0 compiler as GPL-3.0-or-later AND GPL-3.0-or-later WITH GCC-exception-3.1: the compiler is under the GPL, and the run-time library that every program links, Ada.Text_IO among it, carries the GCC Runtime Library Exception 3.1, as the header of a-textio.ads states. Three licences meet in a program you build:

The exception is what makes the middle row harmless: it lets you combine the run-time library with your own code, compiled by an eligible process such as GNAT, and convey the result on terms of your choice, so a program you build need not be GPL.

Practise: read a build log the way the compiler means it

The exercise turns the messages of this lesson into code: split a line of a build log into its file, line, column, kind, text and switch, then say whether a build with a given profile stops. Its sample tests replay the lesson’s own logs, the four messages about limits.adb and the three errors about brackets.adb.

def parse(line):
    """The parts of one GNAT message (file, line, column, kind, text, switch), or None for any other line."""
    # Replace this line with your code.
    return None


def build_fails(profile, lines):
    """Whether a build with this profile ("development", "validation" or "release") stops on these log lines."""
    # Replace this line with your code.
    return False

from messages import build_fails, parse

LIMITS = [
    "Compile",
    "   [Ada]          limits.adb",
    'limits.adb:6:04: warning: variable "Spare" is not referenced [-gnatwu]',
    'limits.adb:8:19: (style) "and then" required [-gnatyB]',
    'limits.adb:9:07: (style) bad casing of "Put_Line" declared at a-textio.ads:565 [-gnatyr]',
    "limits.adb:9:80: (style) this line is too long: 85 [-gnatyM]",
    "Bind",
]

BRACKETS = [
    'brackets.adb:5:31: error: illegal character, replaced by "("',
    "brackets.adb:10:20: error: target name is an Ada 2022 feature",
    "brackets.adb:10:20: error: unit must be compiled with -gnat2022 switch",
]


def test_a_warning():
    """The unused variable: a warning, with the switch that reports it"""
    assert parse(LIMITS[2]) == {"file": "limits.adb", "line": 6, "column": 4, "kind": "warning", "text": 'variable "Spare" is not referenced', "switch": "-gnatwu"}


def test_style_messages():
    """The three style messages, one of them with a colon inside its text"""
    assert parse(LIMITS[3])["kind"] == "style"
    assert parse(LIMITS[3])["text"] == '"and then" required'
    assert parse(LIMITS[4])["text"] == 'bad casing of "Put_Line" declared at a-textio.ads:565'
    assert parse(LIMITS[4])["switch"] == "-gnatyr"
    assert parse(LIMITS[5]) == {"file": "limits.adb", "line": 9, "column": 80, "kind": "style", "text": "this line is too long: 85", "switch": "-gnatyM"}


def test_an_error_without_a_switch():
    """An error from the Ada 2012 build: no brackets at the end"""
    assert parse(BRACKETS[0]) == {"file": "brackets.adb", "line": 5, "column": 31, "kind": "error", "text": 'illegal character, replaced by "("', "switch": None}
    assert parse(BRACKETS[2])["text"] == "unit must be compiled with -gnat2022 switch"


def test_a_switch_in_words():
    """The warning about a value out of range ends with [enabled by default]"""
    m = parse('marks.adb:11:35: warning: Constraint_Error will be raised at run time [enabled by default]')
    assert m["kind"] == "warning"
    assert m["switch"] == "enabled by default"
    assert m["text"] == "Constraint_Error will be raised at run time"


def test_brackets_inside_the_text():
    """A message that ends with ] but has no switch keeps its whole text"""
    m = parse("scores.adb:3:10: error: no index 5 in Scores[1 .. 4]")
    assert m["text"] == "no index 5 in Scores[1 .. 4]"
    assert m["switch"] is None


def test_other_lines():
    """Progress lines and the last line of a build are not messages"""
    assert parse("Compile") is None
    assert parse("   [Ada]          limits.adb") is None
    assert parse("Success: Build finished successfully in … seconds.") is None
    assert parse("") is None


def test_the_profiles():
    """The draft builds with development and stops with validation; an error stops every profile"""
    assert build_fails("development", LIMITS) is False
    assert build_fails("validation", LIMITS) is True
    assert build_fails("release", LIMITS) is False
    assert build_fails("development", BRACKETS) is True
    assert build_fails("release", BRACKETS) is True
    assert build_fails("validation", ["Compile", "Bind", "Link"]) is False

Then test yourself on the six ideas of this lesson, from installing alr to the licences. Your weakest idea is asked about first, and a wrong pick names the slip behind it:

Interview questions

Warm-up (fresher to mid-level): What are Alire, GNAT and GPRbuild, and which one does alr build run?

GNAT is the Ada compiler, part of the GNU Compiler Collection. GPRbuild is the build tool that reads a .gpr project file and runs the compiler, the binder and the linker on the right files in the right order. Alire is Ada’s package and toolchain manager: its alr command installs GNAT and GPRbuild as crates, keeps a crate’s dependencies in alire.toml, and writes the compiler switches of the chosen build profile into config/. alr build runs all three in turn: alr prepares the configuration, then calls GPRbuild with the crate’s project file, and GPRbuild runs GNAT. You can still call gprbuild yourself, through alr exec --, with the same project file.

Two questions an Ada team might put to a new colleague who will run its builds:

Key takeaways

• Alire 2.1.1 is installed from one zip, and alr toolchain --select gnat_native=16.1.0 gprbuild=26.0.1 pins the compiler and the build tool; alr init, alr build and alr run then make, build and start a crate.
• A crate is alire.toml plus a GPR project file; alr writes the compiler switches into config/ on every build, so you never edit that folder.
• The development profile compiled with 31 switches, warnings and style checks among them, but only validation enables assertions with -gnata and turns warnings into errors with -gnatwe; release keeps optimisation only.
• GNAT’s messages name their place and the switch that produced them, and the same four messages that the development build printed stopped the validation build.
• GNAT 16 compiles Ada 2012 by default, so every crate here sets "*".ada_version = "Ada2022"; the compiler is under the GPL, and the run-time library’s exception leaves your program’s licence to you.