Changeset 47bd204

Timestamp:

Feb 5, 2024, 2:17:51 AM (10 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

c17dc80, e11cdc0

Parents:

a55ebcc (diff), be4335b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• doc/proposals/enum.tex (modified) (6 diffs)
• src/GenPoly/Box.cpp (modified) (7 diffs)

doc/proposals/enum.tex

@@ -121 +121 @@
 Naming values is a common practice in mathematics and engineering, e.g., $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), MHz (1E6), etc.
 Naming is also commonly used to represent many other numerical phenomenon, such as days of the week, months of a year, floors of a building (basement), time (noon, New Years).
-Many programming languages capture this important capability through a mechanism called an \newterm{enumeration}.
+Many programming languages capture this important software-engineering capability through a mechanism called an \newterm{enumeration}.
 An enumeration is similar to other programming-language types by providing a set of constrained values, but adds the ability to name \emph{all} the values in its set.
 Note, all enumeration names must be unique but different names can represent the same value (eight note, quaver), which are synonyms.
 
-Specifically, an enumerated type is a type whose values are restricted to a fixed set of named constants.
+Specifically, an enumerated type restricts its values to a fixed set of named constants.
 Fundamentally, all types are restricted to a fixed set of values because of the underlying von Neumann architecture, and hence, to a corresponding set of constants, e.g., @3@, @3.5@, @3.5+2.1i@, @'c'@, @"abc"@, etc.
 However, the values for basic types are not named, other than the programming-language supplied constants.
@@ -132 +132 @@
 \section{C-Style Enum}
 
-The C-Style enumeration has the following syntax and semantics.
+The C-Style enumeration has the following syntax and semantics, and is representative of enumerations in many other programming languages (see Section~\ref{s:RelatedWork}).
 \begin{lstlisting}[label=lst:weekday]
 enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday };
@@ -139 +139 @@
 \end{lstlisting}
 Here, the enumeration type @Weekday@ defines the ordered \newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
-The successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@.
-A C enumeration is implemented by an integral type, with consecutive enumerator values assigned by the compiler starting at zero or the next explicitly initialized value.
-For example, @Monday@ to @Wednesday@ have values 0--2 implicitly set by the compiler, @Thursday@ is explicitly set to @10@, and @Friday@ to @Sunday@ have values 11--13 implicitly set by the compiler.
-
-There are 3 attributes for an enumeration: \newterm{position}, \newterm{label}, and \newterm{value}:
+By convention, the successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@, independent of the associated enumerator constants.
+Because an enumerator is a constant, it cannot appear in a mutable context, e.g. @Mon = Sun@ is meaningless, and has no address, it is an rvalue\footnote{
+The term rvalue defines an expression that can only appear on the right-hand side of an assignment.}.
+Enumerators without explicitly designated constants are auto-initialized by the compiler: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
+For example, @Monday@ to @Wednesday@ are implicitly assigned with constants 0--2, @Thursday@ is explicitly set to constant @10@, and @Friday@ to @Sunday@ are implicitly assigned with constants 11--13.
+Hence, there are 3 universal enumeration attributes: \newterm{position}, \newterm{label}, and \newterm{value}:
 \begin{cquote}
 \small\sf\setlength{\tabcolsep}{3pt}
 \begin{tabular}{rccccccccccc}
-@enum@ Weekday \{       & Monday,       & Tuesday,      & Wednesday,    & Thursday=10,  & Friday,       & Saturday,     & Sunday \}; \\
-\it position            & 0                     & 1                     & 2                             & 3                             & 4                     & 5                     & 6                     \\
-\it label                       & Monday        & Tuesday       & Wednesday             & Thursday              & Friday        & Saturday      & Sunday        \\
-\it value                       & 0                     & 1                     & 2                             & {\color{red}10}& 11           & 12            & 13
+@enum@ Weekday \{       & Monday,       & Tuesday,      & Wednesday,    & Thursday = 10,& Friday,       & Saturday,     & Sunday \}; \\
+\it\color{red}position          & 0                     & 1                     & 2                             & 3                             & 4                     & 5                     & 6                     \\
+\it\color{red}label                     & Monday        & Tuesday       & Wednesday             & Thursday              & Friday        & Saturday      & Sunday        \\
+\it\color{red}value                     & 0                     & 1                     & 2                             & {\color{red}10}& 11           & 12            & 13
 \end{tabular}
 \end{cquote}
-
-The enumerators of an enumeration are unscoped, i.e., enumerators declared inside of an @enum@ are visible in the enclosing scope of the @enum@ type.
+Finally, C enumerators are \newterm{unscoped}, i.e., enumerators declared inside of an @enum@ are visible in the enclosing scope of the @enum@ type.
+
+In theory, a C enumeration \emph{variable} is an implementation-defined integral type large enough to hold all enumerated values.
+In practice, since integral constants in C have type @int@ (unless qualified with a size suffix), C uses @int@ as the underlying type for enumeration variables.
 Furthermore, there is an implicit bidirectional conversion between an enumeration and integral types.
 \begin{lstlisting}[label=lst:enum_scope]
 {
         enum Weekday { ... };                           $\C{// enumerators implicitly projected into local scope}$
-        Weekday weekday = Monday;
+        Weekday weekday = Monday;                       $\C{// weekday == 0}$
         weekday = Friday;                                       $\C{// weekday == 11}$
-        int i = Sunday                                          $\C{// i == 13}$
-        weekday = 10000;                                        $\C{// undefined behaviour}$
+        int i = Sunday                                          $\C{// implicit conversion to int, i == 13}$
+        weekday = 10000;                                        $\C{// UNDEFINED! implicit conversion to Weekday}$
 }
 int j = Wednesday;                                              $\C{// ERROR! Wednesday is not declared in this scope}$
 \end{lstlisting}
+The implicit conversion from @int@ to an enumeration type is an unnecessary source of error.
 
 \section{\CFA-Style Enum}
@@ -175 +179 @@
 
 \CFA extends the enumeration by parameterizing the enumeration with a type for the enumerators, allowing enumerators to be assigned any values from the declared type.
-\begin{lstlisting}[label=lst:color]
-enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
-enum( @double@ ) Planet { Venus = 4.87, Earth = 5.97, Mars = 0.642  }; // mass
-enum( @char *@ ) Colour { Red = "red", Green = "green", Blue = "blue"  };
-enum( @Currency@ ) Europe { Euro = '$\texteuro$', Pound = '$\textsterling$' }; // intersection
-\end{lstlisting}
-The types of the enumerators are @char@, @double@, and @char *@ and each enumerator is initialized with corresponding type values.
-% Only types with a defined ordering can be automatically initialized (see Section~\ref{s:AutoInitializable}).
-
-% An instance of \CFA-enum (denoted as @<enum_instance>@) is a label for the defined enum name.
-% The label can be retrieved by calling the function @label( <enum_instance> )@.
-% Similarly, the @value()@ function returns the value used to initialize the \CFA-enum.
+Figure~\ref{f:EumeratorTyping} shows a series of examples illustrating that all \CFA types can be use with an enumeration and each type's constants used to set the enumerators.
+
+Typed enumerates deals with \emph{harmonizing} problem between an enumeration and its companion data.
+The following example is from the \CFA compiler, written in \CC.
+\begin{lstlisting}
+enum integral_types { chr, schar, uschar, sshort, ushort, sint, usint, ..., NO_OF_ITYPES };
+char * integral_names[NO_OF_ITYPES] = {
+        "char", "signed char", "unsigned char",
+        "signed short int", "unsigned short int",
+        "signed int", "unsigned int",
+        ...
+};
+\end{lstlisting}
+The \emph{harmonizing} problem occurs because the enumeration declaration is in one header file and the names are declared in another translation unit.
+It is up to the programmer to ensure changes made in one location are harmonized with the other location (by identifying this requirement within a comment).
+The typed enumeration largely solves this problem by combining and managing the two data types.
+\begin{lstlisting}
+enum( char * ) integral_types {
+        chr = "char", schar = "signed char", uschar = "unsigned char",
+        sshort = "signed short int", ushort = "unsigned short int",
+        sint = "signed int", usint = "unsigned int",
+        ...
+};
+\end{lstlisting}
+
+% \begin{lstlisting}[label=lst:color]
+% struct S { int i, j; };
+% enum( S ) s { A = { 3,  4 }, B = { 7,  8 } };
+% enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
+% enum( @double@ ) Planet { Venus = 4.87, Earth = 5.97, Mars = 0.642  }; // mass
+% enum( @char *@ ) Colour { Red = "red", Green = "green", Blue = "blue"  };
+% enum( @Currency@ ) Europe { Euro = '$\texteuro$', Pound = '$\textsterling$' }; // intersection
+% \end{lstlisting}
+
+\begin{figure}
+\begin{lstlisting}
+// integral
+        enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
+        enum( @signed char@ ) srgb { Red = -1, Green = 0, Blue = 1 };
+        enum( @long long int@ ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
+// non-integral
+        enum( @double@ ) Math { PI_2 = 1.570796, PI = 3.141597, E = 2.718282 };
+        enum( @_Complex@ ) Plane { X = 1.5+3.4i, Y = 7+3i, Z = 0+0.5i };
+// pointer
+        enum( @char *@ ) Names { Fred = "Fred", Mary = "Mary", Jane = "Jane" };
+        int i, j, k;
+        enum( @int *@ ) ptr { I = &i,  J = &j,  K = &k };
+        enum( @int &@ ) ref { I = i,   J = j,   K = k };
+// tuple
+        enum( @[int, int]@ ) { T = [ 1, 2 ] };
+// function
+        void f() {...}   void g() {...}
+        enum( @void (*)()@ ) funs { F = f,  G = g };
+// aggregate
+        struct Person { char * name; int age, height; };
+        enum( @Person@ ) friends { Liz = { "Elizabeth", 22, 170 }, Beth = Liz, Jon = { "Jonathan", 35, 190 } };
+\end{lstlisting}
+\caption{Enumerator Typing}
+\label{f:EumeratorTyping}
+\end{figure}
+
+\subsection{Pure Enumerators}
+
+An empty type, @enum()@, implies the enumerators are pure symbols without values;
+hence, there is no default conversion to @int@. 
+
+\begin{lstlisting}
+enum() Mode { O_RDONLY, O_WRONLY, O_CREAT, O_TRUNC, O_APPEND };
+Mode iomode = O_RDONLY;
+int i = iomode;                                                 $\C{\color{red}// disallowed}$
+sout | O_TRUNC;                                                 $\C{\color{red}// disallowed}$
+\end{lstlisting}
+
+\subsection{Enumerator Subset}
+
+If follows from enumerator typing that the type of the enumerators can be another enumerator.
+\begin{lstlisting}
+enum( char ) Letter { A = 'A',  B = 'B', C = 'C', ..., Z = 'Z' };
+enum( Letter ) Greek { Alph = A, Beta = B, ..., Zeta = Z }; // alphabet intersection
+Letter letter = A;
+Greak greek = Alph;
+letter = Alph;                                                  $\C{// allowed}$
+greek = A;                                                              $\C{\color{red}// disallowed}$
+\end{lstlisting}
+Enumeration @Greek@ may have more or less enumerators than @Letter@, but the enumerator values must be from @Letter@.
+Therefore, @Greek@ enumerators are a subset of type @Letter@ and are type compatible with enumeration @Letter@, but @Letter@ enumerators are not type compatible with enumeration @Greek@. 
+
+\subsection{Enumeration Inheritance}
+
+\CFA Plan-9 inheritance may be used with enumerations.
+\begin{lstlisting}
+enum( char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
+enum /* inferred */ Name3 { @inline Name2@, Sue = "Sue", Tom = "Tom" };
+\end{lstlisting}
+Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Name@ by containment, and a @Name@ enumeration is a subtype of enumeration @Name2@.
+Note, enumerators must be unique in inheritance but enumerator values may be repeated.
+
+The enumeration type for the inheriting type must be the same as the inherited type;
+hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
+When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
+
+Specifically, the inheritance relationship for Names is:
+\begin{lstlisting}
+Name $\(\subset\)$ Name2 $\(\subset\)$ Name3 $\(\subset\)$ const char *         // enum type of Name
+\end{lstlisting}
+For the given function prototypes, the following calls are valid.
+\begin{cquote}
+\begin{tabular}{ll}
+\begin{lstlisting}
+void f( Name );
+void g( Name2 );
+void h( Name3 );
+void j( const char * );
+\end{lstlisting}
+&
+\begin{lstlisting}
+f( Fred );
+g( Fred );   g( Jill );
+h( Fred );   h( Jill );   h( Sue );
+j( Fred );   j( Jill );   j( Sue );   j( "Will" );
+\end{lstlisting}
+\end{tabular}
+\end{cquote}
+Note, the validity of calls is the same for call-by-reference as for call-by-value, and const restrictions are the same as for other types.
 
 \subsection{Enumerator Scoping}
@@ -220 +336 @@
 Enumeration Greek may have more or less enumerators than Letter, but the enumerator values must be from Letter.
 Therefore, Greek enumerators are a subset of type Letter and are type compatible with enumeration Letter, but Letter enumerators are not type compatible with enumeration Greek. 
+
+% An instance of \CFA-enum (denoted as @<enum_instance>@) is a label for the defined enum name.
+% The label can be retrieved by calling the function @label( <enum_instance> )@.
+% Similarly, the @value()@ function returns the value used to initialize the \CFA-enum.
 
 \subsubsection{\lstinline{enumerate()}}
@@ -926 +1046 @@
 
 \section{Related Work}
-
-Enumerations exist in many popular programming languages, e.g., Pascal, Ada, \Csharp, \CC, Go, Java, Modula-3, Rust, Swift, Python, and Algebraic data type in functional programming.
-There are a large set of overlapping features for all the languages, but each language has its own unique restrictions and extensions.
-
-\subsection{Pascal}
+\label{s:RelatedWork}
+
+Enumerations exist in many popular programming languages, e.g., Pascal, Ada, \Csharp, \CC, Go, Java, Modula-3, Rust, Swift, Python, and the algebraic data-type in functional programming.
+There are a large set of overlapping features among these languages, but each language has its own unique restrictions and extensions.
+
+\subsection{(Free) Pascal}
+
+Free Pascal is a modern object-oriented version of the classic Pascal programming language.
+It allows a C-style enumeration type, where enumerators must be in assigned in ascending numerical order with a constant expression and the range can be non-consecutive.
+\begin{lstlisting}[language=pascal,{moredelim=**[is][\color{red}]{@}{@}}]
+Type EnumType = ( one, two, three, forty @= 40@, fortyone );
+\end{lstlisting}
+Pseudo-functions @Pred@ and @Succ@ can only be used if the range is consecutive.
+The underlying type is an implementation-defined integral type large enough to hold all enumerated values; it does not have to be the smallest possible type.
+The size underlying integral type can be explicitly specified using compiler directive @$PACKENUM@~$N$, where $N$ is the number of bytes, e.g.:
+\begin{lstlisting}[language=pascal,{moredelim=**[is][\color{red}]{@}{@}}]
+Type @{$\color{red}\$$PACKENUM 1}@ SmallEnum = ( one, two, three );
+            @{$\color{red}\$$PACKENUM 4}@ LargeEnum = ( BigOne, BigTwo, BigThree );
+Var S : SmallEnum; { 1 byte }
+          L : LargeEnum; { 4 bytes}
+\end{lstlisting}
+
 
 \subsection{Ada}
 
+An enumeration type is defined as a list of possible values:
+\begin{lstlisting}[language=ada]
+type RGB is (Red, Green, Blue);
+\end{lstlisting}
+Like for numeric types, where e.g., 1 is an integer literal, @Red@, @Green@ and @Blue@ are called the literals of this type.
+There are no other values assignable to objects of this type.
+
+\paragraph{Operators and attributes} ~\newline
+Apart from equality (@"="@), the only operators on enumeration types are the ordering operators: @"<"@, @"<="@, @"="@, @"/="@, @">="@, @">"@, where the order relation is given implicitly by the sequence of literals:
+Each literal has a position, starting with 0 for the first, incremented by one for each successor.
+This position can be queried via the @'Pos@ attribute; the inverse is @'Val@, which returns the corresponding literal. In our example:
+\begin{lstlisting}[language=ada]
+RGB'Pos (Red) = 0
+RGB'Val (0)   = Red
+\end{lstlisting}
+There are two other important attributes: @Image@ and @Value@.
+@Image@ returns the string representation of the value (in capital letters), @Value@ is the inverse:
+\begin{lstlisting}[language=ada]
+RGB'Image ( Red ) = "RED"
+RGB'Value ("Red") =  Red
+\end{lstlisting}
+These attributes are important for simple IO (there are more elaborate IO facilities in @Ada.Text_IO@ for enumeration types).
+Note that, since Ada is case-insensitive, the string given to @'Value@ can be in any case.
+
+\paragraph{Enumeration literals} ~\newline
+Literals are overloadable, i.e. you can have another type with the same literals.
+\begin{lstlisting}[language=ada]
+type Traffic_Light is (Red, Yellow, Green);
+\end{lstlisting}
+Overload resolution within the context of use of a literal normally resolves which @Red@ is meant.
+Only if you have an unresolvable overloading conflict, you can qualify with special syntax which @Red@ is meant:
+\begin{lstlisting}[language=ada]
+RGB'(Red)
+\end{lstlisting}
+Like many other declarative items, enumeration literals can be renamed.
+In fact, such a literal is actually a function, so it has to be renamed as such:
+\begin{lstlisting}[language=ada]
+function Red return P.RGB renames P.Red;
+\end{lstlisting}
+Here, @RGB@ is assumed to be defined in package @P@, which is visible at the place of the renaming declaration.
+Renaming makes @Red@ directly visible without necessity to resort the use-clause.
+
+Note that redeclaration as a function does not affect the staticness of the literal.
+
+\paragraph{Characters as enumeration literals} ~\newline
+Rather unique to Ada is the use of character literals as enumeration literals:
+\begin{lstlisting}[language=ada]
+type ABC is ('A', 'B', 'C');
+\end{lstlisting}
+This literal @'A'@ has nothing in common with the literal @'A'@ of the predefined type @Character@ (or @Wide_Character@).
+
+Every type that has at least one character literal is a character type.
+For every character type, string literals and the concatenation operator @"&"@ are also implicitly defined.
+\begin{lstlisting}[language=ada]
+type My_Character is (No_Character, 'a', Literal, 'z');
+type My_String is array (Positive range <>) of My_Character;
+
+S: My_String := "aa" & Literal & "za" & 'z';
+T: My_String := ('a', 'a', Literal, 'z', 'a', 'z');
+\end{lstlisting}
+In this example, @S@ and @T@ have the same value.
+
+Ada's @Character@ type is defined that way.
+See Ada Programming/Libraries/Standard.
+
+\paragraph{Booleans as enumeration literals} ~\newline
+Also Booleans are defined as enumeration types:
+\begin{lstlisting}[language=ada]
+type Boolean is (False, True);
+\end{lstlisting}
+There is special semantics implied with this declaration in that objects and expressions of this type can be used as conditions.
+Note that the literals @False@ and @True@ are not Ada keywords.
+
+Thus it is not sufficient to declare a type with these literals and then hope objects of this type can be used like so:
+\begin{lstlisting}[language=ada]
+type My_Boolean is (False, True);
+Condition: My_Boolean;
+
+if Condition then -- wrong, won't compile
+\end{lstlisting}
+
+If you need your own Booleans (perhaps with special size requirements), you have to derive from the predefined Boolean:
+\begin{lstlisting}[language=ada]
+type My_Boolean is new Boolean;
+Condition: My_Boolean;
+
+if Condition then -- OK
+\end{lstlisting}
+
+\paragraph{Enumeration subtypes} ~\newline
+You can use range to subtype an enumeration type:
+\begin{lstlisting}[language=ada]
+subtype Capital_Letter is Character range 'A' .. 'Z';
+type Day_Of_Week is (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday);
+subtype Working_Day is Day_Of_Week range Monday .. Friday;
+\end{lstlisting}
+
+\paragraph{Using enumerations} ~\newline
+Enumeration types being scalar subtypes, type attributes such as @First@ and @Succ@ will allow stepping through a subsequence of the values.
+\begin{lstlisting}[language=ada]
+case Day_Of_Week'First is
+        when Sunday =>
+           ISO (False);
+        when Day_Of_Week'Succ(Sunday) =>
+           ISO (True);
+        when Tuesday .. Saturday =>
+           raise Program_Error;
+end case;
+\end{lstlisting}
+A loop will automatically step through the values of the subtype's range.
+Filtering week days to include only working days with an even position number:
+\begin{lstlisting}[language=ada]
+        for Day in Working_Day loop
+                if Day_Of_Week'Pos(Day) mod 2 = 0 then
+                        Work_In_Backyard;
+                end if;
+        end loop;
+\end{lstlisting}
+Enumeration types can be used as array index subtypes, yielding a table feature:
+\begin{lstlisting}[language=ada]
+type Officer_ID is range 0 .. 50;
+type Schedule is array (Working_Day) of Officer_ID;
+\end{lstlisting}
+
+\begin{lstlisting}[language=ada]
+type Subtype_Name is (Id1, Id2, Id3 ... );
+\end{lstlisting}
+where @Id1@, @Id2@, etc. are identifiers or characters literals.
+In either case, the legal values of the type are referred to as "enumeration literals."
+Each of these values has a "position number" corresponding to its position in the list such that @Id1@ has position 0, @Id2@ has position 1, and the Nth value has position N-1.
+
+\paragraph{Attributes of Enumeration Types} ~\newline
+An enumeration type, @T@, has the following attributes: @T'First@, @T'Last@, @T'Range@, @T'Pred@, @T'Succ@, @T'Min@, @T'Max@, @T'Image@, @T'Wide_Image@, @T'Value@, @T'Wide_Value@, @T'Pos@, and @T'Val@ (pronounced "T tick first", "T tick last", etc.).
+Most of these are illustrated in the example program given below, and most of them produce what you would intuitively expect based on their names.
+
+@T'Image@ and @T'Value@ form a complementary pair of attributes.
+The former takes a value in @T@ and returns a String representation of that value.
+The latter takes a @String@ that is a representation of a value in @T@ and returns that value.
+
+@T'Pos@ and @T'Val@ form another complementary pair.
+The former takes a value in @T@ and returns its position number.
+The latter takes a position number and returns the corresponding value of type @T@.
+
+
 \subsection{\Csharp}
 
 \subsection{\CC}
 
-Because \CC is backwards compatible with C, it inherited C's enumerations, except there is no implicit conversion from an integral value to an enumeration;
-hence, the values in a \CC enumeration can only be its enumerators.
-
-\CC{11} extended enumeration with a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are local to the enumeration and are accessed using type qualification, e.g., @Weekday::Monday@.
+\CC is backwards compatible with C, so it inherited C's enumerations, except there is no implicit conversion from an integral value to an enumeration;
+hence, the values in a \CC enumeration can only be its enumerators (without a cast).
+There is no mechanism to iterate through an enumeration.
+
+\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), so the enumerators are local to the enumeration and must be accessed using type qualification, e.g., @Weekday::Monday@.
 \CC{20} supports unscoped access with a \lstinline[language=c++]{using enum} declaration.
 
-For both unscoped and scoped enumerations, the underlying type is an implementation-defined integral type that is large enough to hold all enumerated values; it does not have to be the smallest possible type.
-The underlying integral type can be explicitly specified:
+For both unscoped and scoped enumerations, the underlying type is an implementation-defined integral type large enough to hold all enumerated values; it does not have to be the smallest possible type.
+In \CC{11}, the underlying integral type can be explicitly specified:
 \begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
 enum class RGB : @long@ { Red, Green, Blue };
 enum class rgb : @char@ { Red = 'r', Green = 'g', Blue = 'b' };
 enum class srgb : @signed char@ { Red = -1, Green = 0, Blue = 1 };
+RGB colour1 = @RGB::@Red;
+rgb colour2 = @rgb::@Red;
+srgb colour3 = @srgb::@Red;
 \end{lstlisting}
 

src/GenPoly/Box.cpp

@@ -25 +25 @@
 #include "AST/GenericSubstitution.hpp" // for genericSubstitution
 #include "CodeGen/OperatorTable.h"     // for isAssignment
+#include "Common/Iterate.hpp"          // for group_iterate
 #include "Common/ScopedMap.h"          // for ScopedMap
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
-#include "Common/utility.h"            // for toCString, group_iterate
 #include "GenPoly/FindFunction.h"      // for findFunction
 #include "GenPoly/GenPoly.h"           // for getFunctionType, ...
@@ -236 +237 @@
         ) );
         // TODO: Polymorphic types will be out of the struct declaration scope.
-        // Should be removed by PolyGenericCalculator.
+        // This breaks invariants until it is corrected later.
         for ( auto const & member : enumerate( decl->members ) ) {
                 auto dwt = member.val.strict_as<ast::DeclWithType>();
@@ -309 +310 @@
         ) );
         // TODO: Polymorphic types will be out of the union declaration scope.
+        // This breaks invariants until it is corrected later.
         for ( auto const & member : decl->members ) {
                 auto dwt = member.strict_as<ast::DeclWithType>();
@@ -575 +577 @@
                 if ( adapters.contains( mangleName ) ) continue;
                 std::string adapterName = makeAdapterName( mangleName );
-                // TODO: The forwarding here is problematic because these
-                // declarations are not rooted anywhere in the translation unit.
+                // NODE: This creates floating nodes, breaking invariants.
+                // This is corrected in the RewireAdapters sub-pass.
                 adapters.insert(
                         mangleName,
@@ -639 +641 @@
 
         TypeVarMap exprTypeVars;
-        // TODO: Should this take into account the variables already bound in
-        // scopeTypeVars ([ex] remove them from exprTypeVars)?
         makeTypeVarMap( function, exprTypeVars );
         auto dynRetType = isDynRet( function, exprTypeVars );
@@ -1521 +1521 @@
 
 // --------------------------------------------------------------------------
-// TODO: Ideally, there would be no floating nodes at all.
 /// Corrects the floating nodes created in CallAdapter.
 struct RewireAdapters final : public ast::WithGuards {
@@ -1837 +1836 @@
 
         // Not all members of a polymorphic type are themselves of a polymorphic
-        // type; in this cas the member expression should be wrapped and
+        // type; in this case the member expression should be wrapped and
         // dereferenced to form an lvalue.
         if ( !isPolyType( memberType, scopeTypeVars ) ) {