Changeset b110bcc

Jenkins/Promote

-              r2ed94a9
+              rb110bcc
                 dir (BuildDir) {
                     sh 'rm -rf *'
                         sshagent (credentials: ['github_key_jun1']) {
+                        sshagent (credentials: ['git_key_mar27']) {
                                 sh "git clone --bare ${RemoteRepo} repo"
+                        }
 …
                         sh "git status"
                         sh "git diff-index --quiet HEAD || git commit -m 'Push from build machine: ${name}'"
                         sshagent (credentials: ['github_key_jun1']) {
+                        sshagent (credentials: ['git_key_mar27']) {
                                 sh "git push origin master"
+                        }

doc/LaTeXmacros/common.sty

-              r2ed94a9
+              rb110bcc
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat Apr  2 17:35:23 2022
 %% Update Count     : 570
+%% Last Modified On : Tue Apr  4 12:03:19 2023
+%% Update Count     : 585
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \setlist[itemize,1]{label=\textbullet}% local
 %\renewcommand{\labelitemi}{{\raisebox{0.25ex}{\footnotesize$\bullet$}}}
 \setlist[enumerate]{listparindent=\parindent}% global
+\setlist[enumerate]{topsep=0.5ex,parsep=0.25ex,itemsep=0.25ex,listparindent=\parindent}% global
 \setlist[enumerate,2]{leftmargin=\parindent,labelsep=*,align=parleft,label=\alph*.}% local
 \setlist[description]{topsep=0.5ex,itemsep=0pt,listparindent=\parindent,leftmargin=\parindent,labelsep=1.5ex}
 …
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name
+\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\usepackage{pslatex}                                                                    % reduce size of san serif font
+\usepackage[scaled=0.85]{helvet}                                                % descent Helvetica font and scale to times size
+\usepackage[T1]{fontenc}
 \usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{rotating}
 …
 \newcommand{\viz}{\VIZ\CheckPeriod}
+\newcommand{\VS}{\abbrevFont{vs}}
+\newcommand{\vs}{\VS\CheckPeriod}
 \newenvironment{cquote}{%
         \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
 …
 \renewcommand{\reftextpagerange}[2]{\unskip, pp.~\pageref{#1}--\pageref{#2}}
 \newcommand{\VRef}[2][Section]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vref{#2}}
+\newcommand{\VRefrange}[3][Sections]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vrefrange{#2}{#3}}
 \newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}}
+\newcommand{\VPagerefrange}[3][pages]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}{#3}}
 \let\Oldthebibliography\thebibliography
 …
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 \newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}}
+\newcommand{\LstNumberStyle}[1]{{\lst@basicstyle{\lst@numberstyle{#1}}}}
 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
 …
 columns=fullflexible,
 basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
 stringstyle=\tt,                                                % use typewriter font
+stringstyle=\small\tt,                                  % use typewriter font
 tabsize=5,                                                              % N space tabbing
 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation

doc/LaTeXmacros/common.tex

-              r2ed94a9
+              rb110bcc
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Tue Apr 26 16:02:48 2022
 %% Update Count     : 558
+%% Last Modified On : Tue Apr  4 12:03:18 2023
+%% Update Count     : 567
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name
+\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\usepackage{pslatex}                                                                    % reduce size of san serif font
+\usepackage[scaled=0.85]{helvet}                                                % descent Helvetica font and scale to times size
+\usepackage[T1]{fontenc}
 \usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{rotating}
 …
 \newcommand{\viz}{\VIZ\CheckPeriod}
+\newcommand{\VS}{\abbrevFont{vs}}
+\newcommand{\vs}{\VS\CheckPeriod}
 \makeatother
 …
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 \newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}}
+\newcommand{\LstNumberStyle}[1]{{\lst@basicstyle{\lst@numberstyle{#1}}}}
 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
 …
 columns=fullflexible,
 basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
 stringstyle=\tt,                                                % use typewriter font
+stringstyle=\small\tt,                                  % use typewriter font
 tabsize=5,                                                              % N space tabbing
 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation

doc/bibliography/pl.bib

-              r2ed94a9
+              rb110bcc
     author      = {Zhang, Yizhou and Salvaneschi, Guido and Beightol, Quinn and Liskov, Barbara and Myers, Andrew C.},
     title       = {Accepting Blame for Safe Tunneled Exceptions},
     booktitle   = {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
+    organization= {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
     series      = {PLDI'16},
     year        = {2016},
 …
    },
    comment      = {Mentions Thoth in reference to delegation}
+}
+@misc{ActorBenchmarks,
+    keywords    = {Actors, microbenchmarks, uC++. CAF, AkkaC, AkkaT, ProtoActor},
+    contributer = {pabuhr@plg},
+    key         = {ActorBenchmarks},
+    title       = {Actor Benchmarks},
+    author      = {Peter A. Buhr and Colby A. Parsons},
+    howpublished= {\href{https://github.com/pabuhr/ActorExperiments}{https://\-github.com/\-pabuhr/\-ActorExperiments}},
+    year        = 2022,
+}
 …
+}
+@manual{Ada95,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {{A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization= {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+}
+@manual{Ada12,
+    keywords    = {ISO/IEC Ada},
+    contributer = {pabuhr@plg},
+    author      = {Ada12},
+    title       = {Programming languages -- {Ada} ISO/IEC 8652:2012},
+    edition     = {3rd},
+    organization= {International Standard Organization},
+    address     = {Geneva, Switzerland},
+    year        = 2012,
+    note        = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}},
+}
+@manual{Ada95:annotated,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {Annotated {A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization= {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+}
 @article{dim:ada,
     keywords    = {Dimensional Analysis, Ada},
 …
     number      = 2,
     pages       = {189-203},
+}
+@article{Agrawal08,
+    keywords    = {Adaptive scheduling, adversary, instantaneous parallelism, job scheduling, multiprocessing, multiprogramming, parallel computation, parallelism feedback, processor allocation, randomized algorithm, space sharing, span, thread scheduling, trim analysis, two-level scheduling, work, work-stealing},
+    author      = {Agrawal, Kunal and Leiserson, Charles E. and He, Yuxiong and Hsu, Wen Jing},
+    title       = {Adaptive Work-stealing with Parallelism Feedback},
+    journal     = {ACM Trans. Comput. Syst.},
+    issue_date  = {September 2008},
+    volume      = {26},
+    number      = {3},
+    month       = sep,
+    year        = {2008},
+    pages       = {7:1-7:32},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
     year        = 2016,
     note        = {\href{http://doc.akka.io/docs/akka/2.4/AkkaScala.pdf}{http://\-doc.akka.io/\-docs/\-akka/\-2.4/\-AkkaScala.pdf}},
+}
+@misc{AkkaFuture,
+    contributer = {pabuhr@plg},
+    key         = {AkkaFuture},
+    title       = {Akka Futures},
+    author      = {{Lightbend}},
+    howpublished= {\href{https://doc.akka.io/docs/akka/2.5/futures.html}{https://\-doc.akka.io/\-docs/\-akka/\-2.5/\-futures.html}},
+    year        = 2022,
+}
 …
+}
+@inproceedings{Mitzenmacher98,
+    author      = {Mitzenmacher, Michael},
+    title       = {Analyses of Load Stealing Models Based on Differential Equations},
+    organization= {Proceedings of the Tenth Annual ACM Symposium on Parallel Algorithms and Architectures},
+    series      = {SPAA '98},
+    year        = {1998},
+    isbn        = {0-89791-989-0},
+    location    = {Puerto Vallarta, Mexico},
+    pages       = {212-221},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Squillante91,
+    author      = {Squillante, Mark S. and Nelson, Randolph D.},
+    title       = {Analysis of Task Migration in Shared-memory Multiprocessor Scheduling},
+    organization= {Proceedings of the 1991 ACM SIGMETRICS Conference on Measurement and Modeling of Computer Systems},
+    series      = {SIGMETRICS '91},
+    year        = {1991},
+    isbn        = {0-89791-392-2},
+    location    = {San Diego, California, USA},
+    pages       = {143-155},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @article{Sinha00,
     author      = {Saurabh Sinha and Mary Jean Harrold},
 …
     author      = {Martin P. Robillard and Gail C. Murphy},
     title       = {Analyzing Exception Flow in {J}ava Programs},
     booktitle   = {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly
+    organization= {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly
                    with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering},
     year        = 1999,
 …
     author      = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout},
     title       = {Arachne: Core-Aware Thread Management},
     booktitle   = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
+    organization= {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
     year        = {2018},
     address     = {Carlsbad, CA},
 …
     author      = {Jaewoong Chung and Luke Yen and Stephan Diestelhorst and Martin Pohlack and Michael Hohmuth and David Christie and Dan Grossman},
     title       = {ASF: AMD64 Extension for Lock-Free Data Structures and Transactional Memory},
     booktitle   = {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture},
+    organization= {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture},
     series      = {MICRO '43},
     year        = 2010,
 …
+}
+@misc{AsyncAwait,
+    contributer = {pabuhr@plg},
+    key         = {AsyncAwait},
+    title       = {Async Await},
+    author      = {{WikipediA}},
+    howpublished= {\href{https://en.wikipedia.org/wiki/Async/await}{https://\-en.wikipedia.org/\-wiki/\-Async/\-await}},
+    year        = 2022,
+}
 @inproceedings{Krischer08,
     keywords    = {exception handling, asynchronous, blocked tasks},
 …
     author      = {Roy Krischer and Peter A. Buhr},
     title       = {Asynchronous Exception Propagation in Blocked Tasks},
     booktitle   = {4th International Workshop on Exception Handling (WEH.08)},
+    organization= {4th International Workshop on Exception Handling (WEH.08)},
     optorganization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)},
     address     = {Atlanta, U.S.A},
 …
 @article{Joung00,
+    keywords    = {group mutual exclusion, congenial talking philosophers, resource allocation, shared-memory algorithms},
     author      = {Joung, Yuh-Jzer},
     title       = {Asynchronous group mutual exclusion},
 …
     publisher   = {ACM},
     address     = {New York, NY, USA},
+}
+@techreport{Neill09,
+    author      = {Daniel Neill and Adam Wierman},
+    title       = {On the Benefits of Work Stealing in Shared-Memory Multiprocessors},
+    institution = {Carnegie Mellon University},
+    address     = {California Institute of Technology, Pasadena, CA, USA},
+    note        = {\href{http://www.cs.cmu.edu/~acw/15740/paper.pdf}{http://\-www.cs.cmu.edu/\-$\sim$acw/\-15740/\-paper.pdf}, Accessed May 2014},
+    year        = 2009,
+}
 …
+}
+@inproceedings{Ding12,
+    keywords    = {fairness, multicore, time sharing, work stealing},
+    author      = {Ding, Xiaoning and Wang, Kaibo and Gibbons, Phillip B. and Zhang, Xiaodong},
+    title       = {BWS: Balanced Work Stealing for Time-sharing Multicores},
+    organization= {Proceedings of the 7th ACM European Conference on Computer Systems},
+    series      = {EuroSys '12},
+    year        = {2012},
+    location    = {Bern, Switzerland},
+    pages       = {365-378},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 % C
 …
     year        = 2015,
     note        = {\href{https://www.iso.org/standard/64031.html}{https://\-www.iso.org/\-standard/\-64031.html}},
+}
+@inproceedings{CAF,
+    keywords    = {performance measurement, actor model, c++, message-oriented middleware, distributed debugging},
+    author      = {Charousset, Dominik and Hiesgen, Raphael and Schmidt, Thomas C.},
+    title       = {{CAF} - the {C}++ Actor Framework for Scalable and Resource-Efficient Applications},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    organization= {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
+    pages       = {15-28},
+    numpages    = {14},
+    location    = {Portland, Oregon, USA},
+    series      = {AGERE'14},
+    year        = {2014},
+}
 …
 @techreport{Prokopec11,
     keywords    = {ctrie, concurrent map},
     contributer = {a3moss@uwaterloo.ca},
+    contributer = {a3moss@uwaterloo.ca},
     title       = {Cache-aware lock-free concurrent hash tries},
     author      = {Prokopec, Aleksandar and Bagwell, Phil and Odersky, Martin},
 …
     author      = {Emery D. Berger and Benjamin G. Zorn and Kathryn S. McKinley},
     title       = {Composing High-Performance Memory Allocators},
     booktitle   = {{SIGPLAN} Conference on Programming Language Design and Implementation},
+    organization= {{SIGPLAN} Conference on Programming Language Design and Implementation},
     pages       = {114-124},
     year        = 2001,
 …
     address     = {Eindhoven, Neth.},
     year        = 1965,
+    note        = {Reprinted in \cite{Genuys68} pp. 43--112.}
+    optnote     = {Reprinted in \cite{Genuys68} pp. 43--112.},
+    note        = {\url{https://pure.tue.nl/ws/files/4279816/344354178746665.pdf}},
+}
 …
     author      = {Adya, Atul and Howell, Jon and Theimer, Marvin and Bolosky, William J. and Douceur, John R.},
     title       = {Cooperative Task Management Without Manual Stack Management},
     booktitle   = {Proc. of the General Track USENIX Tech. Conf.},
+    organization= {Proc. of the General Track USENIX Tech. Conf.},
     series      = {ATEC '02},
     year        = {2002},
 …
     year        = 2016,
     note        = {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}},
+}
+@article{Acar02,
+    author      = {Acar, Umut A. and Blelloch, Guy E. and Blumofe, Robert D.},
+    title       = {The Data Locality of Work Stealing},
+    journal     = {Theory of Computing Systems},
+    volume      = {35},
+    number      = {3},
+    year        = {2002},
+    publisher   = {Springer-Verlag},
+    pages       = {321-347},
+}
 …
     editor      = {R. E. A. Mason},
     organization= {IFIP},
     publisher = {North-Holland},
     summary = {
+    publisher   = {North-Holland},
+    summary     = {
         Packages group related declarations or subprograms, and encapsulate
         data types.  Separate interfaces and bodies promotes information
 …
     address     = {Waterview Corporate Center, 20 Waterview Boulevard, Parsippany, NJ 07054},
     year        = {1993}
+}
+@inproceedings{Chen14,
+    keywords    = {Core allocation, Multi-programmed, Work-stealing},
+    author      = {Chen, Quan and Zheng, Long and Guo, Minyi},
+    title       = {DWS: Demand-aware Work-Stealing in Multi-programmed Multi-core Architectures},
+    organization= {Proceedings of Programming Models and Applications on Multicores and Manycores},
+    series      = {PMAM'14},
+    year        = {2007},
+    location    = {Orlando, FL, USA},
+    pages       = {131:131-131:139},
+    articleno   = {131},
+    numpages    = {9},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
     year        = 2003,
     pages       = {29-35},
+}
+@inproceedings{Hamidzadeh96,
+    keywords    = {processor scheduling, resource allocation, shared memory systems, average memory referencing delay},
+    author      = {Hamidzadeh, B. and Lilja, D.J.},
+    booktitle   = {Distributed Computing Systems, 1996., Proceedings of the 16th International Conference on},
+    title       = {Dynamic scheduling strategies for shared-memory multiprocessors},
+    year        = {1996},
+    month       = {May},
+    pages       = {208-215},
+}
+@article{Hendler06,
+    keywords    = {Concurrent programming; Load balancing; Work stealing; Lock-free; Data structures},
+    author      = {Hendler, Danny and Lev, Yossi and Moir, Mark and Shavit, Nir},
+    title       = {A dynamic-sized nonblocking work stealing deque},
+    journal     = {Distributed Computing},
+    volume      = {18},
+    number      = {3},
+    year        = {2006},
+    publisher   = {Springer-Verlag},
+    pages       = {189-207},
+}
 …
+}
+@inproceedings{Blelloch04,
+    keywords    = {chip multiprocessors, multithreaded architectures, scheduling algorithms, shared cache},
+    author      = {Blelloch, Guy E. and Gibbons, Phillip B.},
+    title       = {Effectively Sharing a Cache Among Threads},
+    organization= {Proceedings of the Sixteenth Annual ACM Symposium on Parallelism in Algorithms and Architectures},
+    series      = {SPAA '04},
+    year        = {2004},
+    location    = {Barcelona, Spain},
+    pages       = {235-244},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @techreport{Habermann80,
     keywords    = {Ada, threads},
 …
     title       = {Encapsulation and Inheritance in Object-Oriented Programming Languages},
     journal     = sigplan,
+    volume      = {21},    number = {11},
+    volume      = {21},
+    number      = {11},
     pages       = {38-45},
+    month       = nov, year = 1986,
+    month       = nov,
+    year        = 1986,
     comment     = {
         Client, child interfaces should be distinct.  Child interface
 …
+}
+@inproceedings{Ribic14,
+    keywords    = {dvfs, energy efficiency, language runtimes, thread management, work stealing},
+    author      = {Ribic, Haris and Liu, Yu David},
+    title       = {Energy-efficient Work-stealing Language Runtimes},
+    organization= {Proceedings of the 19th International Conference on Architectural Support for Programming Languages and Operating Systems},
+    series      = {ASPLOS '14},
+    year        = {2014},
+    location    = {Salt Lake City, Utah, USA},
+    pages       = {513-528},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @manual{EPT,
     keywords    = {concurrency, light-weight threads},
 …
     publisher   = {North Oxford Academic},
     year        = 1985
+}
+@article{Torrellas95,
+    author      = {J. Torrellas and A. Tucker and A. Gupta},
+    title       = {Evaluating the Performance of Cache-Affinity Scheduling in Shared-Memory Multiprocessors},
+    journal     = {Journal of Parallel and Distributed Computing},
+    volume      = {24},
+    number      = {2},
+    pages       = {139-151},
+    year        = {1995},
+}
 …
     author      = {Robert Griesemer and Rob Pike and Ken Thompson},
     title       = {{Go} Programming Language},
+    address     = {Mountain View, CA, USA},
     organization= {Google},
     year        = 2009,
 …
 @article{Michael04a,
     keywords    = {Lock-free, synchronization, concurrent programming, memory management, multiprogramming, dynamic data structures},
+    contributer = {pabuhr@plg},
     author      = {Maged M. Michael},
     title       = {Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects},
 …
     publisher   = {IEEE Press},
     address     = {Piscataway, NJ, USA},
+}
+@inproceedings{Johansson02,
+    keywords    = {concurrent languages, erlang, garbage collection, message passing, runtime systems},
+    contributer = {pabuhr@plg},
+    author      = {Erik Johansson and Konstantinos Sagonas and Jesper Wilhelmsson},
+    title       = {Heap Architectures for Concurrent Languages Using Message Passing},
+    year        = {2002},
+    isbn        = {1581135394},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    organization= {Proceedings of the 3rd International Symposium on Memory Management},
+    pages       = {88-99},
+    location    = {Berlin, Germany},
+}
 …
     year        = {1994},
     pages       = {64-69},
+}
+@inproceedings{Halstead84,
+    author      = {Halstead,Jr., Robert H.},
+    title       = {Implementation of Multilisp: Lisp on a Multiprocessor},
+    organization= {Proceedings of the 1984 ACM Symposium on LISP and Functional Programming},
+    series      = {LFP '84},
+    year        = {1984},
+    location    = {Austin, Texas, USA},
+    pages       = {9-17},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
     contributer = {pabuhr@plg},
     author      = {Lua},
+    title       = {Lua 5.3 Reference Manual},
+    address     = {\href{https://www.lua.org/manual/5.3}{https://\-www.lua.org/\-manual/\-5.3}},
+    year        = 2018,
+    title       = {Lua 5.4 Reference Manual},
+    organization= {Pontifical Catholic University},
+    address     = {\href{https://www.lua.org/manual/5.4}{https://\-www.lua.org/\-manual/\-5.4}},
+    year        = 2020,
+}
 …
         Programming Language},
     year        = 1980,
+    month       = dec, pages = {139-145},
+    month       = dec,
+    pages       = {139-145},
     note        = {SIGPLAN Notices, v. 15, n. 11},
     abstract    = {
 …
     year        = 2005,
     pages       = {146-196},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Hendler02,
+    author      = {Hendler, Danny and Shavit, Nir},
+    title       = {Non-blocking Steal-half Work Queues},
+    organization= {Proceedings of the Twenty-first Annual Symposium on Principles of Distributed Computing},
+    series      = {PODC '02},
+    year        = {2002},
+    location    = {Monterey, California},
+    pages       = {280-289},
     publisher   = {ACM},
     address     = {New York, NY, USA},
 …
+}
+@misc{OpenTelemetry,
+    contributer = {pabuhr@plg},
+    key         = {OpenTelemetry},
+    title       = {OpenTelemetry},
+    author      = {{Asynkron AB}},
+    howpublished= {\href{https://proto.actor/docs/tracing}{https://\-proto.actor/\-docs/\-tracing}},
+    year        = 2022,
+}
 @inproceedings{Krebbers14,
     keywords    = {c formalization},
 …
+}
+@article{Nigro21,
+    keywords    = {Actors, Asynchronous messages, Reflective control on message passing, Lock-free parallel computing, Java, Scalable multi-agent systems, Parallel matrix multiplication, Iterated Prisoner's Dilemma},
+    contributer = {pabuhr@plg},
+    author      = {Libero Nigro},
+    title       = {Parallel Theatre: An actor framework in {Java} for high performance computing},
+    journal     = {Simulation Modelling Practice and Theory},
+    volume      = {106},
+    number      = {102189},
+    year        = {2021},
+}
 @incollection{Stroustrup96,
     keywords    = {concurrency, C++},
 …
     journal     = ieeese,
     year        = 1984,
+    month       = sep, volume = "SE-10", number = 5, pages = {528-543},
+    month       = sep,
+    volume      = "SE-10",
+    number      = 5,
+    pages       = {528-543},
     abstract    = {
         Parameterized programming is a powerful technique for the reliable
 …
     booktitle   = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference},
     organization= {USENIX Association},
+    year        = 1988, pages = {1-18}
+    year        = 1988,
+    pages       = {1-18},
+}
 …
+}
+@incollection{Kazempour08,
+    keywords    = {multicore processors; cache affinity; performance evaluation; scheduling},
+    author      = {Kazempour, Vahid and Fedorova, Alexandra and Alagheband, Pouya},
+    title       = {Performance Implications of Cache Affinity on Multicore Processors},
+    organization= {Euro-Par 2008 -- Parallel Processing},
+    series      = {Lecture Notes in Computer Science},
+    editor      = {Luque, Emilio and Margalef, Tomas and Benitez, Domingo},
+    year        = {2008},
+    volume      = {5168},
+    pages       = {151-161},
+    publisher   = {Springer Berlin Heidelberg},
+}
+@article{Anderson89,
+    keywords    = {data structures, multiprocessing systems, operating systems (computers), performance evaluation, critical resource waiting},
+    author      = {Anderson, T.E. and Lazowska, E.D. and Levy, H.M.},
+    journal     = {Computers, IEEE Transactions on},
+    title       = {The Performance Implications of Thread Management Alternatives for Shared-Memory Multiprocessors},
+    year        = {1989},
+    month       = {Dec},
+    volume      = {38},
+    number      = {12},
+    pages       = {1631-1644},
+}
 @article{Anderson90,
     keywords    = {spin locks, back off, performance},
 …
     number      = 1,
     pages       = {6-16},
+}
+@article{Blumofe98,
+    author      = {Blumofe, Robert D. and Papadopoulos, Dionisios},
+    title       = {The Performance of Work Stealing in Multiprogrammed Environments (Extended Abstract)},
+    journal     = {SIGMETRICS Perform. Eval. Rev.},
+    volume      = {26},
+    number      = {1},
+    month       = jun,
+    year        = {1998},
+    issn        = {0163-5999},
+    pages       = {266-267},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
+}
+@manual{Ada95,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {{A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization= {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+}
+@manual{Ada12,
+    keywords    = {ISO/IEC Ada},
+    contributer = {pabuhr@plg},
+    author      = {Ada12},
+    title       = {Programming languages -- {Ada} ISO/IEC 8652:2012},
+    edition     = {3rd},
+    organization= {International Standard Organization},
+    address     = {Geneva, Switzerland},
+    year        = 2012,
+    note        = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}},
+}
+@manual{Ada95:annotated,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {Annotated {A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization = {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+@inproceedings{Bacon03,
+    keywords    = {utilization, real-time scheduling, read barrier, defragmentation},
+    contributer = {pabuhr@plg},
+    author      = {David F. Bacon and Perry Cheng and V. T. Rajan},
+    title       = {A Real-Time Garbage Collector with Low Overhead and Consistent Utilization},
+    year        = {2003},
+    organization= {Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    pages       = {285-298},
+    location    = {New Orleans, Louisiana, USA},
+}
 …
     journal     = sigplan,
     year        = 1991,
+    month       = oct, volume = 26, number = 10, pages = {29-43},
+    month       = oct,
+    volume      = 26,
+    number      = 10,
+    pages       = {29-43},
     abstract    = {
         {\tt lcc} is a new retargetable compiler for ANSI C.  Versions for
 …
     publisher   = {ACM},
     address     = {New York, NY, USA},
     booktitle   = {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
+    organization= {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
     pages       = {67-80},
     numpages    = {14},
 …
+}
+@article{Nickolls08,
+    author      = {Nickolls, John and Buck, Ian and Garland, Michael and Skadron, Kevin},
+    title       = {Scalable Parallel Programming with CUDA},
+    journal     = {Queue},
+    volume      = {6},
+    number      = {2},
+    month       = mar,
+    year        = 2008,
+    pages       = {40-53},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @article{Anderson92,
     keywords    = {light-weight tasks},
 …
+}
+@article{Blumofe99,
+    keywords    = {critical-path length, multiprocessor, multithreading, randomized algorithm, thread scheduling, work stealing},
+    author      = {Blumofe, Robert D. and Leiserson, Charles E.},
+    title       = {Scheduling Multithreaded Computations by Work Stealing},
+    journal     = {Journal of the ACM},
+    volume      = {46},
+    number      = {5},
+    month       = sep,
+    year        = {1999},
+    pages       = {720-748},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Acar13,
+    keywords    = {dynamic load balancing, nested parallelism, work stealing},
+    author      = {Acar, Umut A. and Chargueraud, Arthur and Rainey, Mike},
+    title       = {Scheduling Parallel Programs by Work Stealing with Private Deques},
+    organization= {Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming},
+    series      = {PPoPP '13},
+    year        = {2013},
+    location    = {Shenzhen, China},
+    pages       = {219-228},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Chen07,
+    keywords    = {chip multiprocessors, constructive cache sharing, parallel depth first, scheduling algorithms, thread granularity, work stealing, working set profiling},
+    author      = {Chen, Shimin and Gibbons, Phillip B. and Kozuch, Michael and Liaskovitis, Vasileios and Ailamaki, Anastassia and Blelloch, Guy E. and Falsafi, Babak and Fix, Limor and Hardavellas, Nikos and Mowry, Todd C. and Wilkerson, Chris},
+    title       = {Scheduling Threads for Constructive Cache Sharing on CMPs},
+    organization= {Proceedings of the Nineteenth Annual ACM Symposium on Parallel Algorithms and Architectures},
+    series      = {SPAA '07},
+    year        = {2007},
+    location    = {San Diego, California, USA},
+    pages       = {105-115},
+    numpages    = {11},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @manual{SELF,
     keywords    = {programming language, obect-oriented, polymorphism},
 …
     publisher   = {Springer},
     note        = {Lecture Notes in Computer Science v. 173},
+}
+@inproceedings{Kahn74,
+    keywords    = {programming language, obect-oriented, polymorphism},
+    contributer = {pabuhr@plg},
+    title       = {The Semantics of a Simple Language for Parallel Programming},
+    author      = {Gilles Kahn},
+    booktitle   = {IFIP Congress},
+    year        = 1974,
+}
 …
     publisher   = {Morgan \& Claypool},
     year        = 2013,
+}
+@inproceedings{Leissa14,
+    title       = {{S}ierra: a {SIMD} extension for {C}++},
+    author      = {Lei{\ss}a, Roland and Haffner, Immanuel and Hack, Sebastian},
+    booktitle   = {Proceedings of the 2014 Workshop on Workshop on programming models for SIMD/Vector processing},
+    pages       = {17-24},
+    year        = {2014},
+    organization= {ACM}
+}
 …
+}
+@article{Arora01,
+    author      = {Arora, N. S. and Blumofe, R. D. and Plaxton, C. G.},
+    title       = {Thread Scheduling for Multiprogrammed Multiprocessors},
+    journal     = {Theory of Computing Systems},
+    year        = {2001},
+    volume      = {34},
+    number      = {2},
+    pages       = {115-144},
+    publisher   = {Springer-Verlag},
+}
 @article{Boehm05,
     keywords    = {concurrency, C++},
 …
+}
+@misc{AkkaBecome,
+    contributer = {pabuhr@plg},
+    key         = {AkkaBecome},
+    title       = {Typed Actors},
+    author      = {{Lightbend}},
+    howpublished= {\href{https://doc.akka.io/docs/akka/2.5/typed-actors.html}{https://\-doc.akka.io/\-docs/\-akka/\-2.5/\-typed-actors.html}},
+    year        = 2022,
+}
 @article{concatenation,
     keywords    = {record concatenation, isa},
 …
     author      = {Paul R. Wilson},
     title       = {Uniprocessor Garbage Collection Techniques},
     booktitle   = {Proceedings of the International Workshop on Memory Management},
+    organization= {Proceedings of the International Workshop on Memory Management},
     location    = {St. Malo, France},
     publisher   = {Springer},
 …
     author      = {Carl Hewitt and Peter Bishop and Richard Steiger},
     title       = {A Universal Modular {ACTOR} Formalism for Artificial Intelligence},
     booktitle   = {Proceedings of the 3rd International Joint Conference on Artificial Intelligence},
+    organization= {Proceedings of the 3rd International Joint Conference on Artificial Intelligence},
     address     = {Standford, California, U.S.A.},
     pages       = {235-245},
+    location    = {Stanford, USA},
+    series      = {IJCAI'73},
     month       = aug,
     year        = 1973,
 …
 @article{Karsten20,
     author      = {Karsten, Martin and Barghi, Saman},
     title       = {{User-level Threading: Have Your Cake and Eat It Too}},
+    title       = {User-level Threading: Have Your Cake and Eat It Too},
     year        = {2020},
     issue_date  = {March 2020},
 …
+}
+@article{Squillante93,
+    keywords    = {buffer storage, performance evaluation, queueing theory, scheduling, shared memory systems, processor-cache affinity},
+    author      = {Squillante, M.S. and Lazowska, E.D.},
+    title       = {Using Processor-Cache Affinity Information in Shared-Memory Multiprocessor Scheduling},
+    journal     = {Parallel and Distributed Systems, IEEE Transactions on},
+    year        = {1993},
+    month       = {Feb},
+    volume      = {4},
+    number      = {2},
+    pages       = {131-143},
+}
 @article{delegation,
     keywords    = {delegation, inheritance, actors},
 …
     year        = 2003,
     pages       = {19-24},
+}
+@inproceedings{Saman18,
+    keywords    = {actors, scheduling, NUMA, locality},
+    contributer = {pabuhr@plg},
+    author      = {Saman Barghi and Martin Karsten},
+    organization= {2018 IEEE International Parallel and Distributed Processing Symposium (IPDPS)},
+    title       = {Work-Stealing, Locality-Aware Actor Scheduling},
+    year        = {2018},
+    address     = {Vancouver, BC, Canada},
+    pages       = {484-494},
+}
+@article{Wimmer13,
+    keywords    = {priorities, scheduler hints, strategies, work-stealing},
+    author      = {Wimmer, Martin and Cederman, Daniel and Tr\"{a}ff, Jesper Larsson and Tsigas, Philippas},
+    title       = {Work-stealing with Configurable Scheduling Strategies},
+    journal     = {SIGPLAN Not.},
+    issue_date  = {August 2013},
+    volume      = {48},
+    number      = {8},
+    month       = feb,
+    year        = {2013},
+    issn        = {0362-1340},
+    pages       = {315-316},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}

doc/theses/mike_brooks_MMath/Makefile

-              r2ed94a9
+              rb110bcc
 PicSRC = ${notdir ${wildcard ${Pictures}/*.png}}
 DemoSRC = ${notdir ${wildcard ${Programs}/*-demo.cfa}}
+PgmSRC = ${notdir ${wildcard ${Programs}/*.cfa}}
+PgmSRC = ${notdir ${wildcard ${Programs}/*}}
+RunPgmSRC = ${notdir ${wildcard ${Programs}/*.run.*}}
 BibSRC = ${wildcard *.bib}
 …
 BibLIB = .:../../bibliography                   # common citation repository
 MAKEFLAGS = --no-print-directory # --silent
+#MAKEFLAGS = --no-print-directory # --silent
 VPATH = ${Build} ${Pictures} ${Programs} # extra search path for file names used in document
 …
 BASE = ${basename ${DOCUMENT}}                  # remove suffix
+DemoTex = ${DemoSRC:%.cfa=${Build}/%.tex}
+RunPgmExe = ${addprefix ${Build}/,${basename ${basename ${RunPgmSRC}}}}
+RunPgmOut = ${RunPgmExe:%=%.out}
 # Commands
 LaTeX = TEXINPUTS=${TeXLIB} && export TEXINPUTS && pdflatex -halt-on-error -output-directory=${Build}
 BibTeX = BIBINPUTS=${BibLIB} && export BIBINPUTS && bibtex
+CFA = cfa
+CFA = cfa -O0 -g
+CC  = gcc -O0 -g
+CXX = g++-11 --std=c++20 -O0 -g
 # Rules and Recipes
+.PHONY : all clean                              # not file names
+.PHONY : all fragments_ran clean                        # not file names
+.PRECIOUS : ${Build}/% ${Build}/%-demo      # don't delete intermediates
 .ONESHELL :
+all : ${DOCUMENT}
+all : fragments_ran ${DOCUMENT}
+fragments_ran : $(RunPgmOut)
 clean :
 …
 # File Dependencies
 %.pdf : ${TeXSRC} ${DemoSRC:%.cfa=%.tex} ${PicSRC} ${PgmSRC} ${BibSRC} Makefile | ${Build}
+%.pdf : ${TeXSRC} ${DemoTex} ${PicSRC} ${PgmSRC} ${BibSRC} Makefile | ${Build}
         ${LaTeX} ${BASE}
         ${BibTeX} ${Build}/${BASE}
 …
 %-demo.tex: %-demo | ${Build}
         ${Build}/$< > ${Build}/$@
+        $< > $@
+%-demo: %-demo.cfa
         ${CFA} $< -o ${Build}/$@
+${Build}/%-demo: ${Programs}/%-demo.cfa | ${Build}
+        ${CFA} $< -o $@
+${Build}/%: ${Programs}/%.run.cfa | ${Build}
+        ${CFA} $< -o $@
+${Build}/%: ${Programs}/%.run.c | ${Build}
+        ${CC}  $< -o $@
+${Build}/%: ${Programs}/%.run.cpp | ${Build}
+        ${CXX} -MMD $< -o $@
+${Build}/%.out: ${Build}/% | ${Build}
+        $< > $@
+-include ${Build}/*.d

doc/theses/mike_brooks_MMath/uw-ethesis.bib

-              r2ed94a9
+              rb110bcc
   bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+% --------------------------------------------------
+% Linked-list prior work
+@misc{CFAStackEvaluation,
+    contributer = {a3moss@plg},
+    author      = {Aaron Moss},
+    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
+    year        = 2018,
+    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
+}
+@misc{lst:linuxq,
+  title     = {queue(7) — Linux manual page},
+  howpublished= {\href{https://man7.org/linux/man-pages/man3/queue.3.html}{https://man7.org/linux/man-pages/man3/queue.3.html}},
+}
+  % see also https://man7.org/linux/man-pages/man7/queue.7.license.html
+  %          https://man7.org/tlpi/
+  %          https://www.kernel.org/doc/man-pages/
+@misc{lst:stl,
+  title     = {std::list},
+  howpublished= {\href{https://en.cppreference.com/w/cpp/container/list}{https://en.cppreference.com/w/cpp/container/list}},
+}

doc/theses/mike_brooks_MMath/uw-ethesis.tex

-              r2ed94a9
+              rb110bcc
 % For hyperlinked PDF, suitable for viewing on a computer, use this:
 \documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+\usepackage{times}
 \usepackage[T1]{fontenc}        % Latin-1 => 256-bit characters, => | not dash, <> not Spanish question marks
 …
 \usepackage{comment} % Removes large sections of the document.
 \usepackage{tabularx}
+\usepackage{subfigure}
+\usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt,font=normalsize]{subfig}
+\renewcommand\thesubfigure{(\alph{subfigure})}
 \usepackage{algorithm}
 …
     citecolor=blue,        % color of links to bibliography
     filecolor=magenta,      % color of file links
+    urlcolor=blue           % color of external links
+    urlcolor=blue,           % color of external links
+    breaklinks=true
+}
 \ifthenelse{\boolean{PrintVersion}}{   % for improved print quality, change some hyperref options
 …
 % although it's supposed to be in both the TeX Live and MikTeX distributions. There are also documentation and
 % installation instructions there.
+% Customizing tabularx
+\newcolumntype{Y}{>{\centering\arraybackslash}X}
 % Setting up the page margins...
 …
 \CFAStyle                                               % CFA code-style
 \lstset{language=CFA}                                   % default language
 \lstset{basicstyle=\linespread{0.9}\tt}                 % CFA typewriter font
+\lstset{basicstyle=\linespread{0.9}\sf}                 % CFA typewriter font
 \lstset{inputpath={programs}}
 \newcommand{\PAB}[1]{{\color{red}PAB: #1}}
+\newcommand{\uCpp}{$\mu$\CC}
 %======================================================================
 …
 %----------------------------------------------------------------------
 \begin{sloppypar}
 \input{intro}
 \input{background}
+\input{list}
 \input{array}
 \input{string}

driver/cfa.cc

-              r2ed94a9
+              rb110bcc
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jul 14 21:55:12 2021
 // Update Count     : 467
+// Last Modified On : Mon Apr 10 21:16:00 2023
+// Update Count     : 476
 //
 …
         static int flags = 0;
+    // This allocation 'leaks' memory from the program to the execution
+    // environment, as putenv does not manage the storage of the string used
+    // as an environment variable. This leak is necessary to ensure the
+    // underlying C string is allocated long enough.
         if ( putenv( (char *)( *new string( string( __CFA_FLAGPREFIX__ + to_string( flags++ ) + "__=" ) + arg ) ).c_str() ) ) {
                 cerr << argv[0] << " error, cannot set environment variable." << endl;
 …
                                 } // if
                         } else if ( arg == "-CFA" ) {
                                 CFA_flag = true;                                                // strip the -CFA flag
+                                CFA_flag = true;                                                // strip -CFA flag
                                 link = false;
                                 args[nargs++] = "-fsyntax-only";                // stop after stage 2
                         } else if ( arg == "-debug" ) {
                                 debug = true;                                                   // strip the debug flag
+                                debug = true;                                                   // strip debug flag
                         } else if ( arg == "-nodebug" ) {
                                 debug = false;                                                  // strip the nodebug flag
+                                debug = false;                                                  // strip nodebug flag
                         } else if ( arg == "-quiet" ) {
                                 quiet = true;                                                   // strip the quiet flag
+                                quiet = true;                                                   // strip quiet flag
                         } else if ( arg == "-noquiet" ) {
+                                quiet = false;                                                  // strip the noquiet flag
+                                quiet = false;                                                  // strip noquiet flag
+                        } else if ( arg == "-invariant" ) {
+                                Putenv( argv, "-" + arg );
+                        } else if ( arg == "--invariant" ) {
+                                Putenv( argv, arg );
                         } else if ( arg == "-no-include-stdhdr" ) {
                                 noincstd_flag = true;                                   // strip the no-include-stdhdr flag
+                                noincstd_flag = true;                                   // strip no-include-stdhdr flag
                         } else if ( arg == "-nolib" ) {
                                 nolib = true;                                                   // strip the nolib flag
+                                nolib = true;                                                   // strip nolib flag
                         } else if ( arg == "-help" ) {
                                 help = true;                                                    // strip the help flag
+                                help = true;                                                    // strip help flag
                         } else if ( arg == "-nohelp" ) {
                                 help = false;                                                   // strip the nohelp flag
+                                help = false;                                                   // strip nohelp flag
                         } else if ( arg == "-cfalib") {
                                 compiling_libs = true;
 …
                                 } // if
                         } else if ( prefix( arg, "-B" ) ) {
                                 bprefix = arg.substr(2);                                // strip the -B flag
+                                bprefix = arg.substr(2);                                // strip -B flag
                         } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
                                 args[nargs++] = argv[i];                                // pass flag along
 …
         args[nargs++] = "-fexceptions";                                         // add exception flags (unconditionally)
+        args[nargs++] = "-D_GNU_SOURCE";                                        // force gnu libraries
         // add flags based on the type of compile

libcfa/src/Makefile.am

r2ed94a9	rb110bcc
48	48	math.hfa \
49	49	time_t.hfa \
	50	virtual_dtor.hfa \
50	51	bits/algorithm.hfa \
51	52	bits/align.hfa \

libcfa/src/algorithms/range_iterator.hfa

-              r2ed94a9
+              rb110bcc
 // Author           : Thierry Delisle
 // Created On       : Tue Nov 30 13:06:22 2021
 // Last Modified By :
 // Last Modified On :
 // Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 13 23:10:35 2023
+// Update Count     : 1
 //
+#pragma once
 generator RangeIter {

libcfa/src/bitmanip.hfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Sat Mar 14 18:12:27 2020
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Oct  8 08:28:15 2022
 // Update Count     : 142
+// Last Modified On : Mon Jan  9 09:02:43 2023
+// Update Count     : 144
 //
 #pragma once
+#include "bits/debug.hfa"                                                               // verify
 // Reference: Bit Twiddling Hacks: http://graphics.stanford.edu/%7Eseander/bithacks.html#CountBitsSetNaive

libcfa/src/bits/random.hfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Fri Jan 14 07:18:11 2022
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec 22 20:54:22 2022
 // Update Count     : 178
+// Last Modified On : Mon Mar 20 21:45:24 2023
+// Update Count     : 186
 //
 …
         #define XOSHIRO256PP
         //#define KISS_64
+    // #define SPLITMIX_64
         // 32-bit generators
         //#define XORSHIFT_6_21_7
         #define XOSHIRO128PP
+    // #define SPLITMIX_32
 #else                                                                                                   // 32-bit architecture
         // 64-bit generators
         //#define XORSHIFT_13_7_17
         #define XOSHIRO256PP
+    // #define SPLITMIX_64
         // 32-bit generators
         //#define XORSHIFT_6_21_7
         #define XOSHIRO128PP
+    // #define SPLITMIX_32
 #endif // __x86_64__
 // Define C/CFA PRNG name and random-state.
-// SKULLDUGGERY: typedefs name struct and typedef with the same name to deal with CFA typedef numbering problem.
 #ifdef XOSHIRO256PP
 #define PRNG_NAME_64 xoshiro256pp
 #define PRNG_STATE_64_T GLUE(PRNG_NAME_64,_t)
 typedef struct PRNG_STATE_64_T { uint64_t s0, s1, s2, s3; } PRNG_STATE_64_T;
+typedef struct { uint64_t s0, s1, s2, s3; } PRNG_STATE_64_T;
 #endif // XOSHIRO256PP
 …
 #define PRNG_NAME_32 xoshiro128pp
 #define PRNG_STATE_32_T GLUE(PRNG_NAME_32,_t)
 typedef struct PRNG_STATE_32_T { uint32_t s0, s1, s2, s3; } PRNG_STATE_32_T;
+typedef struct { uint32_t s0, s1, s2, s3; } PRNG_STATE_32_T;
 #endif // XOSHIRO128PP
 …
 #endif // XORSHIFT_12_25_27
+#ifdef SPLITMIX_64
+#define PRNG_NAME_64 splitmix64
+#define PRNG_STATE_64_T uint64_t
+#endif // SPLITMIX32
+#ifdef SPLITMIX_32
+#define PRNG_NAME_32 splitmix32
+#define PRNG_STATE_32_T uint32_t
+#endif // SPLITMIX32
 #ifdef KISS_64
 #define PRNG_NAME_64 kiss_64
 #define PRNG_STATE_64_T GLUE(PRNG_NAME_64,_t)
 typedef struct PRNG_STATE_64_T { uint64_t z, w, jsr, jcong; } PRNG_STATE_64_T;
+typedef struct { uint64_t z, w, jsr, jcong; } PRNG_STATE_64_T;
 #endif // KISS_^64
 …
 #define PRNG_NAME_32 xorwow
 #define PRNG_STATE_32_T GLUE(PRNG_NAME_32,_t)
 typedef struct PRNG_STATE_32_T { uint32_t a, b, c, d, counter; } PRNG_STATE_32_T;
+typedef struct { uint32_t a, b, c, d, counter; } PRNG_STATE_32_T;
 #endif // XOSHIRO128PP
 …
 #ifdef __cforall                                                                                // don't include in C code (invoke.h)
+// https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64
+//
+// Splitmix64 is not recommended for demanding random number requirements, but is often used to calculate initial states
+// for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
+// Also https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64.
+static inline uint64_t splitmix64( uint64_t & state ) {
+    state += 0x9e3779b97f4a7c15;
+    uint64_t z = state;
+    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+    return z ^ (z >> 31);
+} // splitmix64
+static inline void splitmix64_set_seed( uint64_t & state , uint64_t seed ) {
+    state = seed;
+    splitmix64( state );                                                                // prime
+} // splitmix64_set_seed
+// https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
+//
+// Splitmix32 is not recommended for demanding random number requirements, but is often used to calculate initial states
+// for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
+static inline uint32_t splitmix32( uint32_t & state ) {
+    state += 0x9e3779b9;
+    uint64_t z = state;
+    z = (z ^ (z >> 15)) * 0x85ebca6b;
+    z = (z ^ (z >> 13)) * 0xc2b2ae35;
+    return z ^ (z >> 16);
+} // splitmix32
+static inline void splitmix32_set_seed( uint32_t & state, uint64_t seed ) {
+    state = seed;
+    splitmix32( state );                                                                // prime
+} // splitmix32_set_seed
+#ifdef __SIZEOF_INT128__
+//--------------------------------------------------
+static inline uint64_t lehmer64( __uint128_t & state ) {
+        __uint128_t ret = state;
+        state *= 0x_da94_2042_e4dd_58b5;
+        return ret >> 64;
+} // lehmer64
+static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
+        // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
+        state = splitmix64( seed );                                                     // prime
+} // lehmer64_set_seed
+//--------------------------------------------------
+static inline uint64_t wyhash64( uint64_t & state ) {
+        uint64_t ret = state;
+        state += 0x_60be_e2be_e120_fc15;
+        __uint128_t tmp;
+        tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
+        uint64_t m1 = (tmp >> 64) ^ tmp;
+        tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
+        uint64_t m2 = (tmp >> 64) ^ tmp;
+        return m2;
+} // wyhash64
+static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) {
+        state = splitmix64( seed );                                                     // prime
+} // wyhash64_set_seed
+#endif // __SIZEOF_INT128__
 // https://prng.di.unimi.it/xoshiro256starstar.c
 //
 …
 #ifndef XOSHIRO256PP
 typedef struct xoshiro256pp_t { uint64_t s0, s1, s2, s3; } xoshiro256pp_t;
+typedef struct { uint64_t s0, s1, s2, s3; } xoshiro256pp_t;
 #endif // ! XOSHIRO256PP
 …
 static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state, uint64_t seed ) {
+        state = (xoshiro256pp_t){ seed, seed, seed, seed };
+        xoshiro256pp( state );
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint64_t seed1 = splitmix64( seed );                                // prime
+    uint64_t seed2 = splitmix64( seed );
+    uint64_t seed3 = splitmix64( seed );
+    uint64_t seed4 = splitmix64( seed );
+        state = (xoshiro256pp_t){ seed1, seed2, seed3, seed4 };
 } // xoshiro256pp_set_seed
 …
 #ifndef XOSHIRO128PP
 typedef struct xoshiro128pp_t { uint32_t s0, s1, s2, s3; } xoshiro128pp_t;
+typedef struct { uint32_t s0, s1, s2, s3; } xoshiro128pp_t;
 #endif // ! XOSHIRO128PP
 …
 static inline void xoshiro128pp_set_seed( xoshiro128pp_t & state, uint32_t seed ) {
+        state = (xoshiro128pp_t){ seed, seed, seed, seed };
+        xoshiro128pp( state );                                                          // prime
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint32_t seed1 = splitmix32( seed );                                // prime
+    uint32_t seed2 = splitmix32( seed );
+    uint32_t seed3 = splitmix32( seed );
+    uint32_t seed4 = splitmix32( seed );
+        state = (xoshiro128pp_t){ seed1, seed2, seed3, seed4 };
 } // xoshiro128pp_set_seed
-#ifdef __SIZEOF_INT128__
-        //--------------------------------------------------
-        static inline uint64_t lehmer64( __uint128_t & state ) {
-                __uint128_t ret = state;
-                state *= 0x_da94_2042_e4dd_58b5;
-                return ret >> 64;
-        } // lehmer64
-        static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
-                // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
-                state = seed;
-                lehmer64( state );                                                              // prime
-        } // lehmer64_set_seed
-        //--------------------------------------------------
-        static inline uint64_t wyhash64( uint64_t & state ) {
-                uint64_t ret = state;
-                state += 0x_60be_e2be_e120_fc15;
-                __uint128_t tmp;
-                tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
-                uint64_t m1 = (tmp >> 64) ^ tmp;
-                tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
-                uint64_t m2 = (tmp >> 64) ^ tmp;
-                return m2;
-        } // wyhash64
-        static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) {
-                state = seed;
-                wyhash64( state );                                                              // prime
-        } // wyhash64_set_seed
-#endif // __SIZEOF_INT128__
 //--------------------------------------------------
 …
 static inline void xorshift_13_7_17_set_seed( uint64_t & state, uint64_t seed ) {
+        state = seed;
+        xorshift_13_7_17( state );                                                      // prime
+        state = splitmix64( seed );                                                     // prime
 } // xorshift_13_7_17_set_seed
 …
 static inline void xorshift_6_21_7_set_seed( uint32_t & state, uint32_t seed ) {
+        state = seed;
+        xorshift_6_21_7( state );                                                       // prime
+    state = splitmix32( seed );                                                 // prime
 } // xorshift_6_21_7_set_seed
 …
 static inline void xorshift_12_25_27_set_seed( uint64_t & state, uint64_t seed ) {
+        state = seed;
+        xorshift_12_25_27( state );                                                     // prime
+        state = splitmix64( seed );                                                     // prime
 } // xorshift_12_25_27_set_seed
 …
 // The state must be seeded with a nonzero value.
 #ifndef KISS_64
 typedef struct kiss_64_t { uint64_t z, w, jsr, jcong; } kiss_64_t;
+typedef struct { uint64_t z, w, jsr, jcong; } kiss_64_t;
 #endif // ! KISS_64
 …
 static inline void kiss_64_set_seed( kiss_64_t & rs, uint64_t seed ) with(rs) {
+        z = 1; w = 1; jsr = 4; jcong = seed;
+        kiss_64( rs );                                                                          // prime
+        z = 1; w = 1; jsr = 4; jcong = splitmix64( seed );      // prime
 } // kiss_64_set_seed
 …
 // The state array must be initialized to non-zero in the first four words.
 #ifndef XORWOW
 typedef struct xorwow_t { uint32_t a, b, c, d, counter; } xorwow_t;
+typedef struct { uint32_t a, b, c, d, counter; } xorwow_t;
 #endif // ! XORWOW
 …
 static inline void xorwow_set_seed( xorwow_t & rs, uint32_t seed ) {
+        rs = (xorwow_t){ seed, seed, seed, seed, 0 };
+        xorwow( rs );                                                                           // prime
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint32_t seed1 = splitmix32( seed );                                // prime
+    uint32_t seed2 = splitmix32( seed );
+    uint32_t seed3 = splitmix32( seed );
+    uint32_t seed4 = splitmix32( seed );
+        rs = (xorwow_t){ seed1, seed2, seed3, seed4, 0 };
 } // xorwow_set_seed
 …
 // Used in __tls_rand_fwd
 #define M  (1_l64u << 48_l64u)
 #define A  (25214903917_l64u)
 #define AI (18446708753438544741_l64u)
+#define A  (25_214_903_917_l64u)
+#define AI (18_446_708_753_438_544_741_l64u)
 #define C  (11_l64u)
 #define D  (16_l64u)

libcfa/src/concurrency/actor.hfa

-              r2ed94a9
+              rb110bcc
 #include <locks.hfa>
 #include <limits.hfa>
-#include <list.hfa>
 #include <kernel.hfa>
+#include <iofwd.hfa>
+#include <virtual_dtor.hfa>
 #ifdef __CFA_DEBUG__
 …
 // Define the default number of executor request-queues (mailboxes) written to by actors and serviced by the
 // actor-executor threads. Must be greater than 0.
 #define __DEFAULT_EXECUTOR_RQUEUES__ 2
+#define __DEFAULT_EXECUTOR_RQUEUES__ 4
 // Define if executor is created in a separate cluster
 #define __DEFAULT_EXECUTOR_SEPCLUS__ false
+// when you flip this make sure to recompile compiler and flip the appropriate flag there too in Actors.cpp
+#define __ALLOC 0
+#define __DEFAULT_EXECUTOR_BUFSIZE__ 10
+#define __STEAL 0 // workstealing toggle. Disjoint from toggles above
+// workstealing heuristic selection (only set one to be 1)
+// #define RAND 0
+#define SEARCH 1
+// show stats
+// #define ACTOR_STATS
 // forward decls
 struct actor;
 struct message;
+struct executor;
 enum Allocation { Nodelete, Delete, Destroy, Finished }; // allocation status
 …
     __receive_fn fn;
     bool stop;
-    inline dlink(request);
 };
-P9_EMBEDDED( request, dlink(request) )
 static inline void ?{}( request & this ) { this.stop = true; } // default ctor makes a sentinel
 …
+}
+// hybrid data structure. Copies until buffer is full and then allocates for intrusive list
+// Vector-like data structure that supports O(1) queue operations with no bound on size
+// assumes gulping behaviour (once a remove occurs, removes happen until empty beforw next insert)
 struct copy_queue {
-    dlist( request ) list;
-    #if ! __ALLOC
     request * buffer;
+    size_t count, buffer_size, index;
+    #endif
+    size_t count, buffer_size, index, utilized, last_size;
 };
 static inline void ?{}( copy_queue & this ) {}
 static inline void ?{}( copy_queue & this, size_t buf_size ) with(this) {
-    list{};
-    #if ! __ALLOC
     buffer_size = buf_size;
     buffer = aalloc( buffer_size );
     count = 0;
+    utilized = 0;
     index = 0;
+    #endif
+}
+static inline void ^?{}( copy_queue & this ) with(this) {
+    #if ! __ALLOC
+    adelete(buffer);
+    #endif
+}
+    last_size = 0;
+}
+static inline void ^?{}( copy_queue & this ) with(this) { adelete(buffer); }
 static inline void insert( copy_queue & this, request & elem ) with(this) {
+    #if ! __ALLOC
+    if ( count < buffer_size ) { // fast path ( no alloc )
+        buffer[count]{ elem };
+        count++;
+        return;
+    }
+    request * new_elem = alloc();
+    (*new_elem){ elem };
+    insert_last( list, *new_elem );
+    #else
+    insert_last( list, elem );
+    #endif
+    if ( count >= buffer_size ) { // increase arr size
+        last_size = buffer_size;
+        buffer_size = 2 * buffer_size;
+        buffer = realloc( buffer, sizeof( request ) * buffer_size );
+        /* paranoid */ verify( buffer );
+    }
+    memcpy( &buffer[count], &elem, sizeof(request) );
+    count++;
+}
 // once you start removing you need to remove all elements
+// it is not supported to call insert() before the list is fully empty
+// should_delete is an output param
+static inline request & remove( copy_queue & this, bool & should_delete ) with(this) {
+    #if ! __ALLOC
+// it is not supported to call insert() before the array is fully empty
+static inline request & remove( copy_queue & this ) with(this) {
     if ( count > 0 ) {
         count--;
-        should_delete = false;
         size_t old_idx = index;
         index = count == 0 ? 0 : index + 1;
         return buffer[old_idx];
+    }
     #endif
     should_delete = true;
+    return try_pop_front( list );
+}
 static inline bool isEmpty( copy_queue & this ) with(this) {
     #if ! __ALLOC
     return count == 0 && list`isEmpty;
     #else
     return list`isEmpty;
+    #endif
+}
+static size_t __buffer_size = 10; // C_TODO: rework this to be passed from executor through ctors (no need for global)
+    request * ret = 0p;
+    return *0p;
+}
+// try to reclaim some memory if less than half of buffer is utilized
+static inline void reclaim( copy_queue & this ) with(this) {
+    if ( utilized >= last_size || buffer_size <= 4 ) { utilized = 0; return; }
+    utilized = 0;
+    buffer_size--;
+    buffer = realloc( buffer, sizeof( request ) * buffer_size ); // try to reclaim some memory
+}
+static inline bool isEmpty( copy_queue & this ) with(this) { return count == 0; }
 struct work_queue {
     __spinlock_t mutex_lock;
+    copy_queue owned_queue;
+    copy_queue * c_queue; // C_TODO: try putting this on the stack with ptr juggling
+    copy_queue * owned_queue;       // copy queue allocated and cleaned up by this work_queue
+    copy_queue * c_queue;           // current queue
+    volatile bool being_processed;  // flag to prevent concurrent processing
+    #ifdef ACTOR_STATS
+    unsigned int id;
+    size_t missed;                  // transfers skipped due to being_processed flag being up
+    #endif
 }; // work_queue
+static inline void ?{}( work_queue & this ) with(this) {
+    // c_queue = alloc();
+    // (*c_queue){ __buffer_size };
+    owned_queue{ __buffer_size };
+    c_queue = &owned_queue;
+}
+// static inline void ^?{}( work_queue & this ) with(this) { delete( c_queue ); }
+static inline void ?{}( work_queue & this, size_t buf_size, unsigned int i ) with(this) {
+    owned_queue = alloc();      // allocated separately to avoid false sharing
+    (*owned_queue){ buf_size };
+    c_queue = owned_queue;
+    being_processed = false;
+    #ifdef ACTOR_STATS
+    id = i;
+    missed = 0;
+    #endif
+}
+// clean up copy_queue owned by this work_queue
+static inline void ^?{}( work_queue & this ) with(this) { delete( owned_queue ); }
 static inline void insert( work_queue & this, request & elem ) with(this) {
 …
 static inline void transfer( work_queue & this, copy_queue ** transfer_to ) with(this) {
     lock( mutex_lock __cfaabi_dbg_ctx2 );
+    #ifdef __STEAL
+    // check if queue is being processed elsewhere
+    if ( unlikely( being_processed ) ) {
+        #ifdef ACTOR_STATS
+        missed++;
+        #endif
+        unlock( mutex_lock );
+        return;
+    }
+    being_processed = c_queue->count != 0;
+    #endif // __STEAL
+    c_queue->utilized = c_queue->count;
     // swap copy queue ptrs
     copy_queue * temp = *transfer_to;
 …
 } // transfer
+// needed since some info needs to persist past worker lifetimes
+struct worker_info {
+    volatile unsigned long long stamp;
+    #ifdef ACTOR_STATS
+    size_t stolen_from, try_steal, stolen, failed_swaps, msgs_stolen;
+    unsigned long long processed;
+    size_t gulps;
+    #endif
+};
+static inline void ?{}( worker_info & this ) {
+    #ifdef ACTOR_STATS
+    this.stolen_from = 0;
+    this.try_steal = 0;                             // attempts to steal
+    this.stolen = 0;                                // successful steals
+    this.processed = 0;                             // requests processed
+    this.gulps = 0;                                 // number of gulps
+    this.failed_swaps = 0;                          // steal swap failures
+    this.msgs_stolen = 0;                           // number of messages stolen
+    #endif
+    this.stamp = rdtscl();
+}
+// #ifdef ACTOR_STATS
+// unsigned int * stolen_arr;
+// unsigned int * replaced_queue;
+// #endif
 thread worker {
+    copy_queue owned_queue;
+    work_queue * request_queues;
+    work_queue ** request_queues;
     copy_queue * current_queue;
         request & req;
+    executor * executor_;
     unsigned int start, range;
+    int id;
 };
+static inline void ?{}( worker & this, cluster & clu, work_queue * request_queues, unsigned int start, unsigned int range ) {
+#ifdef ACTOR_STATS
+// aggregate counters for statistics
+size_t __total_tries = 0, __total_stolen = 0, __total_workers, __all_gulps = 0,
+    __total_failed_swaps = 0, __all_processed = 0, __num_actors_stats = 0, __all_msgs_stolen = 0;
+#endif
+static inline void ?{}( worker & this, cluster & clu, work_queue ** request_queues, copy_queue * current_queue, executor * executor_,
+    unsigned int start, unsigned int range, int id ) {
     ((thread &)this){ clu };
+    this.request_queues = request_queues;
+    // this.current_queue = alloc();
+    // (*this.current_queue){ __buffer_size };
+    this.owned_queue{ __buffer_size };
+    this.current_queue = &this.owned_queue;
+    this.start = start;
+    this.range = range;
+}
+// static inline void ^?{}( worker & mutex this ) with(this) { delete( current_queue ); }
+    this.request_queues = request_queues;           // array of all queues
+    this.current_queue = current_queue;             // currently gulped queue (start with empty queue to use in swap later)
+    this.executor_ = executor_;                     // pointer to current executor
+    this.start = start;                             // start of worker's subrange of request_queues
+    this.range = range;                             // size of worker's subrange of request_queues
+    this.id = id;                                   // worker's id and index in array of workers
+}
+static bool no_steal = false;
 struct executor {
     cluster * cluster;                                                      // if workers execute on separate cluster
         processor ** processors;                                            // array of virtual processors adding parallelism for workers
+        work_queue * request_queues;                                // master list of work request queues
+        worker ** workers;                                                              // array of workers executing work requests
+        work_queue * request_queues;                                // master array of work request queues
+    copy_queue * local_queues;                      // array of all worker local queues to avoid deletion race
+        work_queue ** worker_req_queues;                // secondary array of work queues to allow for swapping
+    worker ** workers;                                                          // array of workers executing work requests
+    worker_info * w_infos;                          // array of info about each worker
         unsigned int nprocessors, nworkers, nrqueues;   // number of processors/threads/request queues
         bool seperate_clus;                                                             // use same or separate cluster for executor
 }; // executor
+// #ifdef ACTOR_STATS
+// __spinlock_t out_lock;
+// #endif
+static inline void ^?{}( worker & mutex this ) with(this) {
+    #ifdef ACTOR_STATS
+    __atomic_add_fetch(&__all_gulps, executor_->w_infos[id].gulps,__ATOMIC_SEQ_CST);
+    __atomic_add_fetch(&__all_processed, executor_->w_infos[id].processed,__ATOMIC_SEQ_CST);
+    __atomic_add_fetch(&__all_msgs_stolen, executor_->w_infos[id].msgs_stolen,__ATOMIC_SEQ_CST);
+    __atomic_add_fetch(&__total_tries, executor_->w_infos[id].try_steal, __ATOMIC_SEQ_CST);
+    __atomic_add_fetch(&__total_stolen, executor_->w_infos[id].stolen, __ATOMIC_SEQ_CST);
+    __atomic_add_fetch(&__total_failed_swaps, executor_->w_infos[id].failed_swaps, __ATOMIC_SEQ_CST);
+    // per worker steal stats (uncomment alongside the lock above this routine to print)
+    // lock( out_lock __cfaabi_dbg_ctx2 );
+    // printf("Worker id: %d, processed: %llu messages, attempted %lu, stole: %lu, stolen from: %lu\n", id, processed, try_steal, stolen, __atomic_add_fetch(&executor_->w_infos[id].stolen_from, 0, __ATOMIC_SEQ_CST) );
+    // int count = 0;
+    // int count2 = 0;
+    // for ( i; range ) {
+    //     if ( replaced_queue[start + i] > 0 ){
+    //         count++;
+    //         // printf("%d: %u, ",i, replaced_queue[i]);
+    //     }
+    //     if (__atomic_add_fetch(&stolen_arr[start + i],0,__ATOMIC_SEQ_CST) > 0)
+    //         count2++;
+    // }
+    // printf("swapped with: %d of %u indices\n", count, executor_->nrqueues / executor_->nworkers );
+    // printf("%d of %u indices were stolen\n", count2, executor_->nrqueues / executor_->nworkers );
+    // unlock( out_lock );
+    #endif
+}
 static inline void ?{}( executor & this, unsigned int nprocessors, unsigned int nworkers, unsigned int nrqueues, bool seperate_clus, size_t buf_size ) with(this) {
     if ( nrqueues < nworkers ) abort( "nrqueues needs to be >= nworkers\n" );
-    __buffer_size = buf_size;
     this.nprocessors = nprocessors;
     this.nworkers = nworkers;
 …
     this.seperate_clus = seperate_clus;
+    if ( nworkers == nrqueues )
+        no_steal = true;
+    #ifdef ACTOR_STATS
+    // stolen_arr = aalloc( nrqueues );
+    // replaced_queue = aalloc( nrqueues );
+    __total_workers = nworkers;
+    #endif
     if ( seperate_clus ) {
         cluster = alloc();
 …
     request_queues = aalloc( nrqueues );
+    for ( i; nrqueues )
+        request_queues[i]{};
+    worker_req_queues = aalloc( nrqueues );
+    for ( i; nrqueues ) {
+        request_queues[i]{ buf_size, i };
+        worker_req_queues[i] = &request_queues[i];
+    }
     processors = aalloc( nprocessors );
 …
         (*(processors[i] = alloc())){ *cluster };
+    workers = alloc( nworkers );
+    local_queues = aalloc( nworkers );
+    workers = aalloc( nworkers );
+    w_infos = aalloc( nworkers );
     unsigned int reqPerWorker = nrqueues / nworkers, extras = nrqueues % nworkers;
+    for ( i; nworkers ) {
+        w_infos[i]{};
+        local_queues[i]{ buf_size };
+    }
     for ( unsigned int i = 0, start = 0, range; i < nworkers; i += 1, start += range ) {
         range = reqPerWorker + ( i < extras ? 1 : 0 );
         (*(workers[i] = alloc())){ *cluster, request_queues, start, range };
+        (*(workers[i] = alloc())){ *cluster, worker_req_queues, &local_queues[i], &this, start, range, i };
     } // for
+}
 static inline void ?{}( executor & this, unsigned int nprocessors, unsigned int nworkers, unsigned int nrqueues, bool seperate_clus ) { this{ nprocessors, nworkers, nrqueues, seperate_clus, __buffer_size }; }
+static inline void ?{}( executor & this, unsigned int nprocessors, unsigned int nworkers, unsigned int nrqueues, bool seperate_clus ) { this{ nprocessors, nworkers, nrqueues, seperate_clus, __DEFAULT_EXECUTOR_BUFSIZE__ }; }
 static inline void ?{}( executor & this, unsigned int nprocessors, unsigned int nworkers, unsigned int nrqueues ) { this{ nprocessors, nworkers, nrqueues, __DEFAULT_EXECUTOR_SEPCLUS__ }; }
 static inline void ?{}( executor & this, unsigned int nprocessors, unsigned int nworkers ) { this{ nprocessors, nworkers, __DEFAULT_EXECUTOR_RQUEUES__ }; }
 …
 static inline void ^?{}( executor & this ) with(this) {
+    #ifdef __STEAL
+    request sentinels[nrqueues];
+    for ( unsigned int i = 0; i < nrqueues; i++ ) {
+        insert( request_queues[i], sentinels[i] );              // force eventually termination
+    } // for
+    #else
     request sentinels[nworkers];
+    unsigned int reqPerWorker = nrqueues / nworkers;
+    for ( unsigned int i = 0, step = 0; i < nworkers; i += 1, step += reqPerWorker ) {
+    unsigned int reqPerWorker = nrqueues / nworkers, extras = nrqueues % nworkers;
+    for ( unsigned int i = 0, step = 0, range; i < nworkers; i += 1, step += range ) {
+        range = reqPerWorker + ( i < extras ? 1 : 0 );
         insert( request_queues[step], sentinels[i] );           // force eventually termination
     } // for
+    #endif
     for ( i; nworkers )
 …
     } // for
+    #ifdef ACTOR_STATS
+    size_t misses = 0;
+    for ( i; nrqueues ) {
+        misses += worker_req_queues[i]->missed;
+    }
+    // adelete( stolen_arr );
+    // adelete( replaced_queue );
+    #endif
     adelete( workers );
+    adelete( w_infos );
+    adelete( local_queues );
     adelete( request_queues );
+    adelete( worker_req_queues );
     adelete( processors );
     if ( seperate_clus ) delete( cluster );
+    #ifdef ACTOR_STATS // print formatted stats
+    printf("    Actor System Stats:\n");
+    printf("\tActors Created:\t\t\t\t%lu\n\tMessages Sent:\t\t\t\t%lu\n", __num_actors_stats, __all_processed);
+    size_t avg_gulps = __all_gulps == 0 ? 0 : __all_processed / __all_gulps;
+    printf("\tGulps:\t\t\t\t\t%lu\n\tAverage Gulp Size:\t\t\t%lu\n\tMissed gulps:\t\t\t\t%lu\n", __all_gulps, avg_gulps, misses);
+    printf("\tSteal attempts:\t\t\t\t%lu\n\tSteals:\t\t\t\t\t%lu\n\tSteal failures (no candidates):\t\t%lu\n\tSteal failures (failed swaps):\t\t%lu\n",
+        __total_tries, __total_stolen, __total_tries - __total_stolen - __total_failed_swaps, __total_failed_swaps);
+    size_t avg_steal = __total_stolen == 0 ? 0 : __all_msgs_stolen / __total_stolen;
+    printf("\tMessages stolen:\t\t\t%lu\n\tAverage steal size:\t\t\t%lu\n", __all_msgs_stolen, avg_steal);
+    #endif
+}
 // this is a static field of executor but have to forward decl for get_next_ticket
+static unsigned int __next_ticket = 0;
+static inline unsigned int get_next_ticket( executor & this ) with(this) {
+    return __atomic_fetch_add( &__next_ticket, 1, __ATOMIC_SEQ_CST) % nrqueues;
+static size_t __next_ticket = 0;
+static inline size_t __get_next_ticket( executor & this ) with(this) {
+    #ifdef __CFA_DEBUG__
+    size_t temp = __atomic_fetch_add( &__next_ticket, 1, __ATOMIC_SEQ_CST) % nrqueues;
+    // reserve MAX for dead actors
+    if ( unlikely( temp == MAX ) ) temp = __atomic_fetch_add( &__next_ticket, 1, __ATOMIC_SEQ_CST) % nrqueues;
+    return temp;
+    #else
+    return __atomic_fetch_add( &__next_ticket, 1, __ATOMIC_RELAXED) % nrqueues;
+    #endif
 } // tickets
 // C_TODO: update globals in this file to be static fields once the project is done
+// TODO: update globals in this file to be static fields once the static fields project is done
 static executor * __actor_executor_ = 0p;
 static bool __actor_executor_passed = false;        // was an executor passed to start_actor_system
 static unsigned long int __num_actors_;                         // number of actor objects in system
+static bool __actor_executor_passed = false;            // was an executor passed to start_actor_system
+static size_t __num_actors_ = 0;                                        // number of actor objects in system
 static struct thread$ * __actor_executor_thd = 0p;              // used to wake executor after actors finish
 struct actor {
+    unsigned long int ticket;           // executor-queue handle to provide FIFO message execution
+    Allocation allocation_;                     // allocation action
+    size_t ticket;                                          // executor-queue handle
+    Allocation allocation_;                                         // allocation action
+    inline virtual_dtor;
 };
 static inline void ?{}( actor & this ) {
+static inline void ?{}( actor & this ) with(this) {
     // Once an actor is allocated it must be sent a message or the actor system cannot stop. Hence, its receive
     // member must be called to end it
+    verifyf( __actor_executor_, "Creating actor before calling start_actor_system()." );
+    this.allocation_ = Nodelete;
+    this.ticket = get_next_ticket( *__actor_executor_ );
+    __atomic_fetch_add( &__num_actors_, 1, __ATOMIC_SEQ_CST );
+}
+static inline void ^?{}( actor & this ) {}
+    verifyf( __actor_executor_, "Creating actor before calling start_actor_system() can cause undefined behaviour.\n" );
+    allocation_ = Nodelete;
+    ticket = __get_next_ticket( *__actor_executor_ );
+    __atomic_fetch_add( &__num_actors_, 1, __ATOMIC_RELAXED );
+    #ifdef ACTOR_STATS
+    __atomic_fetch_add( &__num_actors_stats, 1, __ATOMIC_SEQ_CST );
+    #endif
+}
 static inline void check_actor( actor & this ) {
 …
+        }
         if ( unlikely( __atomic_add_fetch( &__num_actors_, -1, __ATOMIC_SEQ_CST ) == 0 ) ) { // all actors have terminated
+        if ( unlikely( __atomic_add_fetch( &__num_actors_, -1, __ATOMIC_RELAXED ) == 0 ) ) { // all actors have terminated
             unpark( __actor_executor_thd );
+        }
 …
 struct message {
     Allocation allocation_;                     // allocation action
+    inline virtual_dtor;
 };
+static inline void ?{}( message & this ) { this.allocation_ = Nodelete; }
+static inline void ?{}( message & this, Allocation allocation ) { this.allocation_ = allocation; }
+static inline void ^?{}( message & this ) {}
+static inline void ?{}( message & this ) {
+    this.allocation_ = Nodelete;
+}
+static inline void ?{}( message & this, Allocation allocation ) {
+    memcpy( &this.allocation_, &allocation, sizeof(allocation) ); // optimization to elide ctor
+    verifyf( this.allocation_ != Finished, "The Finished Allocation status is not supported for message types.\n");
+}
+static inline void ^?{}( message & this ) with(this) {
+    CFA_DEBUG( if ( allocation_ == Nodelete ) printf("A message at location %p was allocated but never sent.\n", &this); )
+}
 static inline void check_message( message & this ) {
     switch ( this.allocation_ ) {                                               // analyze message status
         case Nodelete: break;
+        case Nodelete: CFA_DEBUG(this.allocation_ = Finished); break;
         case Delete: delete( &this ); break;
         case Destroy: ^?{}(this); break;
 …
     } // switch
+}
+static inline void set_allocation( message & this, Allocation state ) {
+    this.allocation_ = state;
+}
 static inline void deliver_request( request & this ) {
     Allocation actor_allocation = this.fn( *this.receiver, *this.msg );
     this.receiver->allocation_ = actor_allocation;
+    this.receiver->allocation_ = this.fn( *this.receiver, *this.msg );
+    check_message( *this.msg );
     check_actor( *this.receiver );
+    check_message( *this.msg );
+}
+// tries to atomically swap two queues and returns 0p if the swap failed
+// returns ptr to newly owned queue if swap succeeds
+static inline work_queue * try_swap_queues( worker & this, unsigned int victim_idx, unsigned int my_idx ) with(this) {
+    work_queue * my_queue = request_queues[my_idx];
+    work_queue * other_queue = request_queues[victim_idx];
+    // if either queue is 0p then they are in the process of being stolen
+    if ( other_queue == 0p ) return 0p;
+    // try to set our queue ptr to be 0p. If it fails someone moved our queue so return false
+    if ( !__atomic_compare_exchange_n( &request_queues[my_idx], &my_queue, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) )
+        return 0p;
+    // try to set other queue ptr to be our queue ptr. If it fails someone moved the other queue so fix up then return false
+    if ( !__atomic_compare_exchange_n( &request_queues[victim_idx], &other_queue, my_queue, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) {
+        /* paranoid */ verify( request_queues[my_idx] == 0p );
+        request_queues[my_idx] = my_queue; // reset my queue ptr back to appropriate val
+        return 0p;
+    }
+    // we have successfully swapped and since our queue is 0p no one will touch it so write back new queue ptr non atomically
+    request_queues[my_idx] = other_queue; // last write does not need to be atomic
+    return other_queue;
+}
+// once a worker to steal from has been chosen, choose queue to steal from
+static inline void choose_queue( worker & this, unsigned int victim_id, unsigned int swap_idx ) with(this) {
+    // have to calculate victim start and range since victim may be deleted before us in shutdown
+    const unsigned int queues_per_worker = executor_->nrqueues / executor_->nworkers;
+    const unsigned int extras = executor_->nrqueues % executor_->nworkers;
+    unsigned int vic_start, vic_range;
+    if ( extras > victim_id  ) {
+        vic_range = queues_per_worker + 1;
+        vic_start = vic_range * victim_id;
+    } else {
+        vic_start = extras + victim_id * queues_per_worker;
+        vic_range = queues_per_worker;
+    }
+    unsigned int start_idx = prng( vic_range );
+    unsigned int tries = 0;
+    work_queue * curr_steal_queue;
+    for ( unsigned int i = start_idx; tries < vic_range; i = (i + 1) % vic_range ) {
+        tries++;
+        curr_steal_queue = request_queues[ i + vic_start ];
+        // avoid empty queues and queues that are being operated on
+        if ( curr_steal_queue == 0p || curr_steal_queue->being_processed || isEmpty( *curr_steal_queue->c_queue ) )
+            continue;
+        #ifdef ACTOR_STATS
+        curr_steal_queue = try_swap_queues( this, i + vic_start, swap_idx );
+        if ( curr_steal_queue ) {
+            executor_->w_infos[id].msgs_stolen += curr_steal_queue->c_queue->count;
+            executor_->w_infos[id].stolen++;
+            // __atomic_add_fetch(&executor_->w_infos[victim_id].stolen_from, 1, __ATOMIC_RELAXED);
+            // replaced_queue[swap_idx]++;
+            // __atomic_add_fetch(&stolen_arr[ i + vic_start ], 1, __ATOMIC_RELAXED);
+        } else {
+            executor_->w_infos[id].failed_swaps++;
+        }
+        #else
+        curr_steal_queue = try_swap_queues( this, i + vic_start, swap_idx );
+        #endif // ACTOR_STATS
+        return;
+    }
+    return;
+}
+// choose a worker to steal from
+static inline void steal_work( worker & this, unsigned int swap_idx ) with(this) {
+    #if RAND
+    unsigned int victim = prng( executor_->nworkers );
+    if ( victim == id ) victim = ( victim + 1 ) % executor_->nworkers;
+    choose_queue( this, victim, swap_idx );
+    #elif SEARCH
+    unsigned long long min = MAX; // smaller timestamp means longer since service
+    int min_id = 0; // use ints not uints to avoid integer underflow without hacky math
+    int n_workers = executor_->nworkers;
+    unsigned long long curr_stamp;
+    int scount = 1;
+    for ( int i = (id + 1) % n_workers; scount < n_workers; i = (i + 1) % n_workers, scount++ ) {
+        curr_stamp = executor_->w_infos[i].stamp;
+        if ( curr_stamp < min ) {
+            min = curr_stamp;
+            min_id = i;
+        }
+    }
+    choose_queue( this, min_id, swap_idx );
+    #endif
+}
 void main( worker & this ) with(this) {
+    bool should_delete;
+    // #ifdef ACTOR_STATS
+    // for ( i; executor_->nrqueues ) {
+    //     replaced_queue[i] = 0;
+    //     __atomic_store_n( &stolen_arr[i], 0, __ATOMIC_SEQ_CST );
+    // }
+    // #endif
+    // threshold of empty queues we see before we go stealing
+    const unsigned int steal_threshold = 2 * range;
+    // Store variable data here instead of worker struct to avoid any potential false sharing
+    unsigned int empty_count = 0;
+    request & req;
+    work_queue * curr_work_queue;
     Exit:
     for ( unsigned int i = 0;; i = (i + 1) % range ) { // cycle through set of request buffers
+        // C_TODO: potentially check queue count instead of immediately trying to transfer
+        transfer( request_queues[i + start], &current_queue );
+        curr_work_queue = request_queues[i + start];
+        // check if queue is empty before trying to gulp it
+        if ( isEmpty( *curr_work_queue->c_queue ) ) {
+            #ifdef __STEAL
+            empty_count++;
+            if ( empty_count < steal_threshold ) continue;
+            #else
+            continue;
+            #endif
+        }
+        transfer( *curr_work_queue, &current_queue );
+        #ifdef ACTOR_STATS
+        executor_->w_infos[id].gulps++;
+        #endif // ACTOR_STATS
+        #ifdef __STEAL
+        if ( isEmpty( *current_queue ) ) {
+            if ( unlikely( no_steal ) ) continue;
+            empty_count++;
+            if ( empty_count < steal_threshold ) continue;
+            empty_count = 0;
+            __atomic_store_n( &executor_->w_infos[id].stamp, rdtscl(), __ATOMIC_RELAXED );
+            #ifdef ACTOR_STATS
+            executor_->w_infos[id].try_steal++;
+            #endif // ACTOR_STATS
+            steal_work( this, start + prng( range ) );
+            continue;
+        }
+        #endif // __STEAL
         while ( ! isEmpty( *current_queue ) ) {
+            &req = &remove( *current_queue, should_delete );
+            if ( !&req ) continue; // possibly add some work stealing/idle sleep here
+            #ifdef ACTOR_STATS
+            executor_->w_infos[id].processed++;
+            #endif
+            &req = &remove( *current_queue );
+            if ( !&req ) continue;
             if ( req.stop ) break Exit;
             deliver_request( req );
+            if ( should_delete ) delete( &req );
+        } // while
+        }
+        #ifdef __STEAL
+        curr_work_queue->being_processed = false; // set done processing
+        empty_count = 0; // we found work so reset empty counter
+        #endif
+        // potentially reclaim some of the current queue's vector space if it is unused
+        reclaim( *current_queue );
     } // for
+}
 …
 static inline void send( actor & this, request & req ) {
+    verifyf( this.ticket != (unsigned long int)MAX, "Attempted to send message to deleted/dead actor\n" );
     send( *__actor_executor_, req, this.ticket );
+}
+static inline void __reset_stats() {
+    #ifdef ACTOR_STATS
+    __total_tries = 0;
+    __total_stolen = 0;
+    __all_gulps = 0;
+    __total_failed_swaps = 0;
+    __all_processed = 0;
+    __num_actors_stats = 0;
+    __all_msgs_stolen = 0;
+    #endif
+}
 static inline void start_actor_system( size_t num_thds ) {
+    __reset_stats();
     __actor_executor_thd = active_thread();
     __actor_executor_ = alloc();
 …
+}
+static inline void start_actor_system() { start_actor_system( active_cluster()->procs.total ); }
+// TODO: potentially revisit getting number of processors
+//  ( currently the value stored in active_cluster()->procs.total is often stale
+//  and doesn't reflect how many procs are allocated )
+// static inline void start_actor_system() { start_actor_system( active_cluster()->procs.total ); }
+static inline void start_actor_system() { start_actor_system( 1 ); }
 static inline void start_actor_system( executor & this ) {
+    __reset_stats();
     __actor_executor_thd = active_thread();
     __actor_executor_ = &this;
 …
     __actor_executor_passed = false;
+}
+// Default messages to send to any actor to change status
+// assigned at creation to __base_msg_finished to avoid unused message warning
+message __base_msg_finished @= { .allocation_ : Finished };
+struct __DeleteMsg { inline message; } DeleteMsg = __base_msg_finished;
+struct __DestroyMsg { inline message; } DestroyMsg = __base_msg_finished;
+struct __FinishedMsg { inline message; } FinishedMsg = __base_msg_finished;
+Allocation receive( actor & this, __DeleteMsg & msg ) { return Delete; }
+Allocation receive( actor & this, __DestroyMsg & msg ) { return Destroy; }
+Allocation receive( actor & this, __FinishedMsg & msg ) { return Finished; }

libcfa/src/concurrency/channel.hfa

-              r2ed94a9
+              rb110bcc
+#pragma once
 #include <locks.hfa>
+struct no_reacq_lock {
+    inline exp_backoff_then_block_lock;
+#include <list.hfa>
+#include <mutex_stmt.hfa>
+// link field used for threads waiting on channel
+struct wait_link {
+    // used to put wait_link on a dl queue
+    inline dlink(wait_link);
+    // waiting thread
+    struct thread$ * t;
+    // shadow field
+    void * elem;
 };
+// have to override these by hand to get around plan 9 inheritance bug where resolver can't find the appropriate routine to call
+static inline void   ?{}( no_reacq_lock & this ) { ((exp_backoff_then_block_lock &)this){}; }
+static inline bool   try_lock(no_reacq_lock & this) { return try_lock(((exp_backoff_then_block_lock &)this)); }
+static inline void   lock(no_reacq_lock & this) { lock(((exp_backoff_then_block_lock &)this)); }
+static inline void   unlock(no_reacq_lock & this) { unlock(((exp_backoff_then_block_lock &)this)); }
+static inline void   on_notify(no_reacq_lock & this, struct thread$ * t ) { on_notify(((exp_backoff_then_block_lock &)this), t); }
+static inline size_t on_wait(no_reacq_lock & this) { return on_wait(((exp_backoff_then_block_lock &)this)); }
+// override wakeup so that we don't reacquire the lock if using a condvar
+static inline void   on_wakeup( no_reacq_lock & this, size_t recursion ) {}
+P9_EMBEDDED( wait_link, dlink(wait_link) )
+static inline void ?{}( wait_link & this, thread$ * t, void * elem ) {
+    this.t = t;
+    this.elem = elem;
+}
+// wake one thread from the list
+static inline void wake_one( dlist( wait_link ) & queue ) {
+    wait_link & popped = try_pop_front( queue );
+    unpark( popped.t );
+}
+// returns true if woken due to shutdown
+// blocks thread on list and releases passed lock
+static inline bool block( dlist( wait_link ) & queue, void * elem_ptr, go_mutex & lock ) {
+    wait_link w{ active_thread(), elem_ptr };
+    insert_last( queue, w );
+    unlock( lock );
+    park();
+    return w.elem == 0p;
+}
+// void * used for some fields since exceptions don't work with parametric polymorphism currently
+exception channel_closed {
+    // on failed insert elem is a ptr to the element attempting to be inserted
+    // on failed remove elem ptr is 0p
+    // on resumption of a failed insert this elem will be inserted
+    // so a user may modify it in the resumption handler
+    void * elem;
+    // pointer to chan that is closed
+    void * closed_chan;
+};
+vtable(channel_closed) channel_closed_vt;
+// #define CHAN_STATS // define this to get channel stats printed in dtor
 forall( T ) {
+struct channel {
+    size_t size;
     size_t front, back, count;
+struct __attribute__((aligned(128))) channel {
+    size_t size, front, back, count;
     T * buffer;
+    fast_cond_var( no_reacq_lock ) prods, cons;
+    no_reacq_lock mutex_lock;
+    dlist( wait_link ) prods, cons; // lists of blocked threads
+    go_mutex mutex_lock;            // MX lock
+    bool closed;                    // indicates channel close/open
+    #ifdef CHAN_STATS
+    size_t blocks, operations;      // counts total ops and ops resulting in a blocked thd
+    #endif
 };
 …
     size = _size;
     front = back = count = 0;
     buffer = anew( size );
+    buffer = aalloc( size );
     prods{};
     cons{};
     mutex_lock{};
+    closed = false;
+    #ifdef CHAN_STATS
+    blocks = 0;
+    operations = 0;
+    #endif
+}
 static inline void ?{}( channel(T) &c ){ ((channel(T) &)c){ 0 }; }
+static inline void ^?{}( channel(T) &c ) with(c) { delete( buffer ); }
+static inline void ^?{}( channel(T) &c ) with(c) {
+    #ifdef CHAN_STATS
+    printf("Channel %p Blocks: %lu, Operations: %lu, %.2f%% of ops blocked\n", &c, blocks, operations, ((double)blocks)/operations * 100);
+    #endif
+    verifyf( cons`isEmpty && prods`isEmpty, "Attempted to delete channel with waiting threads (Deadlock).\n" );
+    delete( buffer );
+}
 static inline size_t get_count( channel(T) & chan ) with(chan) { return count; }
 static inline size_t get_size( channel(T) & chan ) with(chan) { return size; }
+static inline bool has_waiters( channel(T) & chan ) with(chan) { return !empty( cons ) || !empty( prods ); }
+static inline bool has_waiting_consumers( channel(T) & chan ) with(chan) { return !empty( cons ); }
+static inline bool has_waiting_producers( channel(T) & chan ) with(chan) { return !empty( prods ); }
+static inline void insert_( channel(T) & chan, T elem ) with(chan) {
+static inline bool has_waiters( channel(T) & chan ) with(chan) { return !cons`isEmpty || !prods`isEmpty; }
+static inline bool has_waiting_consumers( channel(T) & chan ) with(chan) { return !cons`isEmpty; }
+static inline bool has_waiting_producers( channel(T) & chan ) with(chan) { return !prods`isEmpty; }
+// closes the channel and notifies all blocked threads
+static inline void close( channel(T) & chan ) with(chan) {
+    lock( mutex_lock );
+    closed = true;
+    // flush waiting consumers and producers
+    while ( has_waiting_consumers( chan ) ) {
+        cons`first.elem = 0p;
+        wake_one( cons );
+    }
+    while ( has_waiting_producers( chan ) ) {
+        prods`first.elem = 0p;
+        wake_one( prods );
+    }
+    unlock(mutex_lock);
+}
+static inline void is_closed( channel(T) & chan ) with(chan) { return closed; }
+static inline void flush( channel(T) & chan, T elem ) with(chan) {
+    lock( mutex_lock );
+    while ( count == 0 && !cons`isEmpty ) {
+        memcpy(cons`first.elem, (void *)&elem, sizeof(T)); // do waiting consumer work
+        wake_one( cons );
+    }
+    unlock( mutex_lock );
+}
+// handles buffer insert
+static inline void __buf_insert( channel(T) & chan, T & elem ) with(chan) {
     memcpy((void *)&buffer[back], (void *)&elem, sizeof(T));
     count += 1;
 …
+}
+// does the buffer insert or hands elem directly to consumer if one is waiting
+static inline void __do_insert( channel(T) & chan, T & elem ) with(chan) {
+    if ( count == 0 && !cons`isEmpty ) {
+        memcpy(cons`first.elem, (void *)&elem, sizeof(T)); // do waiting consumer work
+        wake_one( cons );
+    } else __buf_insert( chan, elem );
+}
+// needed to avoid an extra copy in closed case
+static inline bool __internal_try_insert( channel(T) & chan, T & elem ) with(chan) {
+    lock( mutex_lock );
+    #ifdef CHAN_STATS
+    operations++;
+    #endif
+    if ( count == size ) { unlock( mutex_lock ); return false; }
+    __do_insert( chan, elem );
+    unlock( mutex_lock );
+    return true;
+}
+// attempts a nonblocking insert
+// returns true if insert was successful, false otherwise
+static inline bool try_insert( channel(T) & chan, T elem ) { return __internal_try_insert( chan, elem ); }
+// handles closed case of insert routine
+static inline void __closed_insert( channel(T) & chan, T & elem ) with(chan) {
+    channel_closed except{&channel_closed_vt, &elem, &chan };
+    throwResume except; // throw closed resumption
+    if ( !__internal_try_insert( chan, elem ) ) throw except; // if try to insert fails (would block), throw termination
+}
 static inline void insert( channel(T) & chan, T elem ) with(chan) {
+    lock( mutex_lock );
+    // check for close before acquire mx
+    if ( unlikely(closed) ) {
+        __closed_insert( chan, elem );
+        return;
+    }
+    lock( mutex_lock );
+    #ifdef CHAN_STATS
+    if ( !closed ) operations++;
+    #endif
+    // if closed handle
+    if ( unlikely(closed) ) {
+        unlock( mutex_lock );
+        __closed_insert( chan, elem );
+        return;
+    }
     // have to check for the zero size channel case
     if ( size == 0 && !empty( cons ) ) {
         memcpy((void *)front( cons ), (void *)&elem, sizeof(T));
         notify_one( cons );
+    if ( size == 0 && !cons`isEmpty ) {
+        memcpy(cons`first.elem, (void *)&elem, sizeof(T));
+        wake_one( cons );
         unlock( mutex_lock );
         return;
+        return true;
+    }
     // wait if buffer is full, work will be completed by someone else
+    if ( count == size ) {
+        wait( prods, mutex_lock, (uintptr_t)&elem );
+    if ( count == size ) {
+        #ifdef CHAN_STATS
+        blocks++;
+        #endif
+        // check for if woken due to close
+        if ( unlikely( block( prods, &elem, mutex_lock ) ) )
+            __closed_insert( chan, elem );
         return;
     } // if
     if ( count == 0 && !empty( cons ) )
         // do waiting consumer work
         memcpy((void *)front( cons ), (void *)&elem, sizeof(T));
     else insert_( chan, elem );
+    if ( count == 0 && !cons`isEmpty ) {
+        memcpy(cons`first.elem, (void *)&elem, sizeof(T)); // do waiting consumer work
+        wake_one( cons );
+    } else __buf_insert( chan, elem );
+    notify_one( cons );
+    unlock( mutex_lock );
+}
+static inline T remove( channel(T) & chan ) with(chan) {
+    lock( mutex_lock );
+    T retval;
+    // have to check for the zero size channel case
+    if ( size == 0 && !empty( prods ) ) {
+        memcpy((void *)&retval, (void *)front( prods ), sizeof(T));
+        notify_one( prods );
+        unlock( mutex_lock );
+        return retval;
+    }
+    // wait if buffer is empty, work will be completed by someone else
+    if (count == 0) {
+        wait( cons, mutex_lock, (uintptr_t)&retval );
+        return retval;
+    }
+    // Remove from buffer
+    unlock( mutex_lock );
+    return;
+}
+// handles buffer remove
+static inline void __buf_remove( channel(T) & chan, T & retval ) with(chan) {
     memcpy((void *)&retval, (void *)&buffer[front], sizeof(T));
     count -= 1;
     front = (front + 1) % size;
+    if (count == size - 1 && !empty( prods ) )
+        insert_( chan, *((T *)front( prods )) );  // do waiting producer work
+    notify_one( prods );
+    unlock( mutex_lock );
+}
+// does the buffer remove and potentially does waiting producer work
+static inline void __do_remove( channel(T) & chan, T & retval ) with(chan) {
+    __buf_remove( chan, retval );
+    if (count == size - 1 && !prods`isEmpty ) {
+        __buf_insert( chan, *(T *)prods`first.elem );  // do waiting producer work
+        wake_one( prods );
+    }
+}
+// needed to avoid an extra copy in closed case and single return val case
+static inline bool __internal_try_remove( channel(T) & chan, T & retval ) with(chan) {
+    lock( mutex_lock );
+    #ifdef CHAN_STATS
+    operations++;
+    #endif
+    if ( count == 0 ) { unlock( mutex_lock ); return false; }
+    __do_remove( chan, retval );
+    unlock( mutex_lock );
+    return true;
+}
+// attempts a nonblocking remove
+// returns [T, true] if insert was successful
+// returns [T, false] if insert was successful (T uninit)
+static inline [T, bool] try_remove( channel(T) & chan ) {
+    T retval;
+    return [ retval, __internal_try_remove( chan, retval ) ];
+}
+static inline T try_remove( channel(T) & chan, T elem ) {
+    T retval;
+    __internal_try_remove( chan, retval );
     return retval;
+}
+// handles closed case of insert routine
+static inline void __closed_remove( channel(T) & chan, T & retval ) with(chan) {
+    channel_closed except{&channel_closed_vt, 0p, &chan };
+    throwResume except; // throw resumption
+    if ( !__internal_try_remove( chan, retval ) ) throw except; // if try to remove fails (would block), throw termination
+}
+static inline T remove( channel(T) & chan ) with(chan) {
+    T retval;
+    if ( unlikely(closed) ) {
+        __closed_remove( chan, retval );
+        return retval;
+    }
+    lock( mutex_lock );
+    #ifdef CHAN_STATS
+    if ( !closed ) operations++;
+    #endif
+    if ( unlikely(closed) ) {
+        unlock( mutex_lock );
+        __closed_remove( chan, retval );
+        return retval;
+    }
+    // have to check for the zero size channel case
+    if ( size == 0 && !prods`isEmpty ) {
+        memcpy((void *)&retval, (void *)prods`first.elem, sizeof(T));
+        wake_one( prods );
+        unlock( mutex_lock );
+        return retval;
+    }
+    // wait if buffer is empty, work will be completed by someone else
+    if (count == 0) {
+        #ifdef CHAN_STATS
+        blocks++;
+        #endif
+        // check for if woken due to close
+        if ( unlikely( block( cons, &retval, mutex_lock ) ) )
+            __closed_remove( chan, retval );
+        return retval;
+    }
+    // Remove from buffer
+    __do_remove( chan, retval );
+    unlock( mutex_lock );
+    return retval;
+}
 } // forall( T )

libcfa/src/concurrency/clib/cfathread.cfa

-              r2ed94a9
+              rb110bcc
 // #define EPOLL_FOR_SOCKETS
+#include <string.h>
 #include "fstream.hfa"
 #include "locks.hfa"
 …
 #include "time.hfa"
 #include "stdlib.hfa"
+#include "iofwd.hfa"
 #include "cfathread.h"
-extern "C" {
-                #include <string.h>
-                #include <errno.h>
+}
 extern void ?{}(processor &, const char[], cluster &, thread$ *);
 extern "C" {
+      extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
+        extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+        extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
+}
 …
+}
-#include <iofwd.hfa>
 extern "C" {
-        #include <unistd.h>
-        #include <sys/types.h>
-        #include <sys/socket.h>
         //--------------------
         // IO operations
 …
                 , protocol);
+        }
         int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len) {
+        int cfathread_bind(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len) {
                 return bind(socket, address, address_len);
+        }
 …
+        }
         int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) {
+        int cfathread_accept(int socket, __SOCKADDR_ARG address, socklen_t *restrict address_len) {
                 #if defined(EPOLL_FOR_SOCKETS)
                         int ret;
 …
+        }
         int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len) {
+        int cfathread_connect(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len) {
                 #if defined(EPOLL_FOR_SOCKETS)
                         int ret;

libcfa/src/concurrency/clib/cfathread.h

-              r2ed94a9
+              rb110bcc
 // Author           : Thierry Delisle
 // Created On       : Tue Sep 22 15:31:20 2020
 // Last Modified By :
 // Last Modified On :
 // Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 13 23:48:40 2023
+// Update Count     : 7
 //
+#pragma once
 #if defined(__cforall) || defined(__cplusplus)
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
 extern "C" {
 #endif
-        #include <asm/types.h>
-        #include <errno.h>
-        #include <unistd.h>
         //--------------------
         // Basic types
 …
         } cfathread_mutexattr_t;
         typedef struct cfathread_mutex * cfathread_mutex_t;
         int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict attr) __attribute__((nonnull (1)));
+        int cfathread_mutex_init(cfathread_mutex_t * restrict mut, const cfathread_mutexattr_t * restrict attr) __attribute__((nonnull (1)));
         int cfathread_mutex_destroy(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
         int cfathread_mutex_lock(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
 …
         //--------------------
         // IO operations
-        struct sockaddr;
-        struct msghdr;
         int cfathread_socket(int domain, int type, int protocol);
         int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len);
+        int cfathread_bind(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len);
         int cfathread_listen(int socket, int backlog);
         int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);
         int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len);
+        int cfathread_accept(int socket, __SOCKADDR_ARG address, socklen_t * restrict address_len);
+        int cfathread_connect(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len);
         int cfathread_dup(int fildes);
         int cfathread_close(int fildes);

libcfa/src/concurrency/coroutine.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec 15 12:06:04 2020
 // Update Count     : 23
+// Last Modified On : Thu Feb 16 15:34:46 2023
+// Update Count     : 24
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "coroutine.hfa"

libcfa/src/concurrency/future.hfa

r2ed94a9	rb110bcc
14	14	//
15	15
16		// #pragma once
	16	#pragma once
17	17
18	18	#include "bits/locks.hfa"

libcfa/src/concurrency/invoke.h

-              r2ed94a9
+              rb110bcc
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Nov 29 20:42:21 2022
+// Update Count     : 56
+//
+// Last Modified On : Tue Mar 14 13:39:31 2023
+// Update Count     : 59
+//
+// No not use #pragma once was this file is included twice in some places. It has its own guard system.
 #include "bits/containers.hfa"

libcfa/src/concurrency/io.cfa

-              r2ed94a9
+              rb110bcc
 #define __cforall_thread__
-#define _GNU_SOURCE
 #if defined(__CFA_DEBUG__)
 …
                                 // make sure the target hasn't stopped existing since last time
                                 HELP: if(target < ctxs_count) {
                                         // calculate it's age and how young it could be before we give ip on helping
+                                        // calculate it's age and how young it could be before we give up on helping
                                         const __readyQ_avg_t cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io, false);
                                         const __readyQ_avg_t age = moving_average(ctsc, io.tscs[target].t.tv, io.tscs[target].t.ma, false);

libcfa/src/concurrency/io/call.cfa.in

-              r2ed94a9
+              rb110bcc
 Prelude = """#define __cforall_thread__
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <time.hfa>
 #include "bits/defs.hfa"
 #include "kernel.hfa"
 …
         #include <assert.h>
         #include <stdint.h>
-        #include <errno.h>
         #include <linux/io_uring.h>
         #include "kernel/fwd.hfa"
 …
 // I/O Forwards
 //=============================================================================================
-#include <time.hfa>
-// Some forward declarations
-#include <errno.h>
-#include <unistd.h>
 extern "C" {
-        #include <asm/types.h>
-        #include <sys/socket.h>
-        #include <sys/syscall.h>
 #if defined(CFA_HAVE_PREADV2)
         struct iovec;
         extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
+        extern ssize_t preadv2 (int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         struct iovec;
         extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
+        extern ssize_t pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags);
 #endif
 …
         struct msghdr;
         struct sockaddr;
+        extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
+        extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
+        extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
+        extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
+        extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+        extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+        extern ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags);
+        extern ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags);
+        extern ssize_t send(int sockfd, const void * buf, size_t len, int flags);
+        extern ssize_t recv(int sockfd, void * buf, size_t len, int flags);
         extern int fallocate(int fd, int mode, off_t offset, off_t len);
         extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
         extern int madvise(void *addr, size_t length, int advice);
         extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
+        extern int madvise(void * addr, size_t length, int advice);
+        extern int openat(int dirfd, const char * pathname, int flags, mode_t mode);
         extern int close(int fd);
         extern ssize_t read (int fd, void *buf, size_t count);
+        extern ssize_t read (int fd, void * buf, size_t count);
         struct epoll_event;
         extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
         extern ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags);
+        extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
+        extern ssize_t splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags);
         extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
+}
 …
 calls = [
         # CFA_HAVE_IORING_OP_READV
         Call('READV', 'ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
+        Call('READV', 'ssize_t preadv2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags)', {
                 'fd'  : 'fd',
+                'addr': '(typeof(sqe->addr))iov',
+                'len' : 'iovcnt',
                 'off' : 'offset',
+                'addr': '(uintptr_t)iov',
+                'len' : 'iovcnt',
+                'rw_flags' : 'flags'
         }, define = 'CFA_HAVE_PREADV2'),
         # CFA_HAVE_IORING_OP_WRITEV
         Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
+        Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags)', {
                 'fd'  : 'fd',
+                'addr': '(typeof(sqe->addr))iov',
+                'len' : 'iovcnt',
                 'off' : 'offset',
+                'addr': '(uintptr_t)iov',
+                'len' : 'iovcnt'
+                'rw_flags' : 'flags'
         }, define = 'CFA_HAVE_PWRITEV2'),
         # CFA_HAVE_IORING_OP_FSYNC
 …
         }),
         # CFA_HAVE_IORING_OP_EPOLL_CTL
         Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)', {
+        Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event)', {
                 'fd': 'epfd',
+                'len': 'op',
                 'addr': 'fd',
+                'len': 'op',
+                'off': '(uintptr_t)event'
+                'off': '(typeof(sqe->off))event'
         }),
         # CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
 …
         }),
         # CFA_HAVE_IORING_OP_SENDMSG
         Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)(struct msghdr *)msg',
+        Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))(struct msghdr *)msg',
                 'len': '1',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_RECVMSG
         Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)(struct msghdr *)msg',
+        Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))(struct msghdr *)msg',
                 'len': '1',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_SEND
         Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)buf',
+        Call('SEND', 'ssize_t send(int sockfd, const void * buf, size_t len, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'len',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_RECV
         Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)buf',
+        Call('RECV', 'ssize_t recv(int sockfd, void * buf, size_t len, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'len',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_ACCEPT
         Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)addr',
                 'addr2': '(uintptr_t)addrlen',
+        Call('ACCEPT', 'int accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))&addr',
+                'addr2': '(typeof(sqe->addr2))addrlen',
                 'accept_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_CONNECT
         Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)addr',
+        Call('CONNECT', 'int connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))&addr',
                 'off': 'addrlen'
         }),
 …
         Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
                 'fd': 'fd',
-                'addr': '(uintptr_t)len',
                 'len': 'mode',
+                'off': 'offset'
+                'off': 'offset',
+                'addr': 'len'
         }),
         # CFA_HAVE_IORING_OP_FADVISE
 …
         }),
         # CFA_HAVE_IORING_OP_MADVISE
         Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
                 'addr': '(uintptr_t)addr',
+        Call('MADVISE', 'int madvise(void * addr, size_t length, int advice)', {
+                'addr': '(typeof(sqe->addr))addr',
                 'len': 'length',
                 'fadvise_advice': 'advice'
         }),
         # CFA_HAVE_IORING_OP_OPENAT
         Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
+        Call('OPENAT', 'int openat(int dirfd, const char * pathname, int flags, mode_t mode)', {
                 'fd': 'dirfd',
                 'addr': '(uintptr_t)pathname',
                 'len': 'mode',
                 'open_flags': 'flags;'
+                'addr': '(typeof(sqe->addr))pathname',
+                'open_flags': 'flags;',
+                'len': 'mode'
         }),
         # CFA_HAVE_IORING_OP_OPENAT2
         Call('OPENAT2', 'int openat2(int dirfd, const char *pathname, struct open_how * how, size_t size)', {
+        Call('OPENAT2', 'int openat2(int dirfd, const char * pathname, struct open_how * how, size_t size)', {
                 'fd': 'dirfd',
                 'addr': 'pathname',
                 'len': 'sizeof(*how)',
                 'off': '(uintptr_t)how',
+                'addr': '(typeof(sqe->addr))pathname',
+                'off': '(typeof(sqe->off))how',
+                'len': 'sizeof(*how)'
         }, define = 'CFA_HAVE_OPENAT2'),
         # CFA_HAVE_IORING_OP_CLOSE
 …
         }),
         # CFA_HAVE_IORING_OP_STATX
         Call('STATX', 'int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf)', {
+        Call('STATX', 'int statx(int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf)', {
                 'fd': 'dirfd',
                 'off': '(uintptr_t)statxbuf',
                 'addr': 'pathname',
+                'addr': '(typeof(sqe->addr))pathname',
+                'statx_flags': 'flags',
                 'len': 'mask',
                 'statx_flags': 'flags'
+                'off': '(typeof(sqe->off))statxbuf'
         }, define = 'CFA_HAVE_STATX'),
         # CFA_HAVE_IORING_OP_READ
         Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
                 'fd': 'fd',
                 'addr': '(uintptr_t)buf',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'count'
         }),
 …
         Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
                 'fd': 'fd',
                 'addr': '(uintptr_t)buf',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'count'
         }),
         # CFA_HAVE_IORING_OP_SPLICE
         Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags)', {
+        Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags)', {
                 'splice_fd_in': 'fd_in',
                 'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
+                'splice_off_in': 'off_in ? (typeof(sqe->splice_off_in))*off_in : (typeof(sqe->splice_off_in))-1',
                 'fd': 'fd_out',
                 'off': 'off_out ? (__u64)*off_out : (__u64)-1',
+                'off': 'off_out ? (typeof(sqe->off))*off_out : (typeof(sqe->off))-1',
                 'len': 'len',
                 'splice_flags': 'flags'

libcfa/src/concurrency/io/setup.cfa

r2ed94a9	rb110bcc
15	15
16	16	#define __cforall_thread__
17		~~#define _GNU_SOURCE~~
18	17
19	18	#if defined(__CFA_DEBUG__)

libcfa/src/concurrency/iofwd.hfa

-              r2ed94a9
+              rb110bcc
 // Author           : Thierry Delisle
 // Created On       : Thu Apr 23 17:31:00 2020
 // Last Modified By :
 // Last Modified On :
 // Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 13 23:54:57 2023
+// Update Count     : 1
 //
 …
 #include <unistd.h>
+#include <sys/socket.h>
 extern "C" {
         #include <asm/types.h>
 …
 typedef __off64_t off64_t;
-struct cluster;
-struct io_context$;
-struct iovec;
-struct msghdr;
-struct sockaddr;
-struct statx;
 struct epoll_event;
-struct io_uring_sqe;
 //-----------------------------------------------------------------------
 …
 // synchronous calls
 #if defined(CFA_HAVE_PREADV2)
         extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern ssize_t cfa_preadv2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         extern ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern ssize_t cfa_pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 extern int cfa_fsync(int fd, __u64 submit_flags);
 extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event, __u64 submit_flags);
+extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event * event, __u64 submit_flags);
 extern int cfa_sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags, __u64 submit_flags);
 extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags, __u64 submit_flags);
 extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags, __u64 submit_flags);
 extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags);
 extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, __u64 submit_flags);
 extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags);
 extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags);
+extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr * msg, int flags, __u64 submit_flags);
+extern ssize_t cfa_recvmsg(int sockfd, struct msghdr * msg, int flags, __u64 submit_flags);
+extern ssize_t cfa_send(int sockfd, const void * buf, size_t len, int flags, __u64 submit_flags);
+extern ssize_t cfa_recv(int sockfd, void * buf, size_t len, int flags, __u64 submit_flags);
+extern int cfa_accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags, __u64 submit_flags);
+extern int cfa_connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen, __u64 submit_flags);
 extern int cfa_fallocate(int fd, int mode, off_t offset, off_t len, __u64 submit_flags);
 extern int cfa_posix_fadvise(int fd, off_t offset, off_t len, int advice, __u64 submit_flags);
 extern int cfa_madvise(void *addr, size_t length, int advice, __u64 submit_flags);
 extern int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode, __u64 submit_flags);
+extern int cfa_madvise(void * addr, size_t length, int advice, __u64 submit_flags);
+extern int cfa_openat(int dirfd, const char * pathname, int flags, mode_t mode, __u64 submit_flags);
 #if defined(CFA_HAVE_OPENAT2)
         extern int cfa_openat2(int dirfd, const char *pathname, struct open_how * how, size_t size, __u64 submit_flags);
+        extern int cfa_openat2(int dirfd, const char * pathname, struct open_how * how, size_t size, __u64 submit_flags);
 #endif
 extern int cfa_close(int fd, __u64 submit_flags);
 #if defined(CFA_HAVE_STATX)
         extern int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, __u64 submit_flags);
+        extern int cfa_statx(int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf, __u64 submit_flags);
 #endif
 extern ssize_t cfa_read(int fd, void * buf, size_t count, __u64 submit_flags);
 extern ssize_t cfa_write(int fd, void * buf, size_t count, __u64 submit_flags);
 extern ssize_t cfa_splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags, __u64 submit_flags);
+extern ssize_t cfa_splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags, __u64 submit_flags);
 extern ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, __u64 submit_flags);
 …
 // asynchronous calls
 #if defined(CFA_HAVE_PREADV2)
         extern void async_preadv2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern void async_preadv2(io_future_t & future, int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         extern void async_pwritev2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern void async_pwritev2(io_future_t & future, int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 extern void async_fsync(io_future_t & future, int fd, __u64 submit_flags);
 extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event *event, __u64 submit_flags);
+extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event * event, __u64 submit_flags);
 extern void async_sync_file_range(io_future_t & future, int fd, off64_t offset, off64_t nbytes, unsigned int flags, __u64 submit_flags);
 extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr *msg, int flags, __u64 submit_flags);
 extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr *msg, int flags, __u64 submit_flags);
 extern void async_send(io_future_t & future, int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags);
 extern void async_recv(io_future_t & future, int sockfd, void *buf, size_t len, int flags, __u64 submit_flags);
 extern void async_accept4(io_future_t & future, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags);
 extern void async_connect(io_future_t & future, int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags);
+extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr * msg, int flags, __u64 submit_flags);
+extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr * msg, int flags, __u64 submit_flags);
+extern void async_send(io_future_t & future, int sockfd, const void * buf, size_t len, int flags, __u64 submit_flags);
+extern void async_recv(io_future_t & future, int sockfd, void * buf, size_t len, int flags, __u64 submit_flags);
+extern void async_accept4(io_future_t & future, int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags, __u64 submit_flags);
+extern void async_connect(io_future_t & future, int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen, __u64 submit_flags);
 extern void async_fallocate(io_future_t & future, int fd, int mode, off_t offset, off_t len, __u64 submit_flags);
 extern void async_posix_fadvise(io_future_t & future, int fd, off_t offset, off_t len, int advice, __u64 submit_flags);
 extern void async_madvise(io_future_t & future, void *addr, size_t length, int advice, __u64 submit_flags);
 extern void async_openat(io_future_t & future, int dirfd, const char *pathname, int flags, mode_t mode, __u64 submit_flags);
+extern void async_madvise(io_future_t & future, void * addr, size_t length, int advice, __u64 submit_flags);
+extern void async_openat(io_future_t & future, int dirfd, const char * pathname, int flags, mode_t mode, __u64 submit_flags);
 #if defined(CFA_HAVE_OPENAT2)
         extern void async_openat2(io_future_t & future, int dirfd, const char *pathname, struct open_how * how, size_t size, __u64 submit_flags);
+        extern void async_openat2(io_future_t & future, int dirfd, const char * pathname, struct open_how * how, size_t size, __u64 submit_flags);
 #endif
 extern void async_close(io_future_t & future, int fd, __u64 submit_flags);
 #if defined(CFA_HAVE_STATX)
         extern void async_statx(io_future_t & future, int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, __u64 submit_flags);
+        extern void async_statx(io_future_t & future, int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf, __u64 submit_flags);
 #endif
 void async_read(io_future_t & future, int fd, void * buf, size_t count, __u64 submit_flags);
 extern void async_write(io_future_t & future, int fd, void * buf, size_t count, __u64 submit_flags);
 extern void async_splice(io_future_t & future, int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags, __u64 submit_flags);
+extern void async_splice(io_future_t & future, int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags, __u64 submit_flags);
 extern void async_tee(io_future_t & future, int fd_in, int fd_out, size_t len, unsigned int flags, __u64 submit_flags);

libcfa/src/concurrency/kernel.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov 30 18:14:08 2022
 // Update Count     : 76
+// Last Modified On : Mon Jan  9 08:42:05 2023
+// Update Count     : 77
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__

libcfa/src/concurrency/kernel/cluster.cfa

-              r2ed94a9
+              rb110bcc
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "bits/defs.hfa"
 …
         return max_cores_l;
+}
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No forward declaration needed
-        #define __kernel_rseq_register rseq_register_current_thread
-        #define __kernel_rseq_unregister rseq_unregister_current_thread
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        static void __kernel_raw_rseq_register  (void);
-        static void __kernel_raw_rseq_unregister(void);
-        #define __kernel_rseq_register __kernel_raw_rseq_register
-        #define __kernel_rseq_unregister __kernel_raw_rseq_unregister
-#else
-        // No forward declaration needed
-        // No initialization needed
-        static inline void noop(void) {}
-        #define __kernel_rseq_register noop
-        #define __kernel_rseq_unregister noop
-#endif
 //=======================================================================
 …
 // Lock-Free registering/unregistering of threads
 unsigned register_proc_id( void ) with(__scheduler_lock.lock) {
-        __kernel_rseq_register();
         bool * handle = (bool *)&kernelTLS().sched_lock;
 …
         __atomic_store_n(cell, 0p, __ATOMIC_RELEASE);
-        __kernel_rseq_unregister();
+}
 …
         /* paranoid */ verify( mock_head(this)    == this.l.prev );
+}
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No definition needed
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        #if defined( __x86_64 ) || defined( __i386 )
-                #define RSEQ_SIG        0x53053053
-        #elif defined( __ARM_ARCH )
-                #ifdef __ARMEB__
-                #define RSEQ_SIG    0xf3def5e7      /* udf    #24035    ; 0x5de3 (ARMv6+) */
-                #else
-                #define RSEQ_SIG    0xe7f5def3      /* udf    #24035    ; 0x5de3 */
-                #endif
-        #endif
-        extern void __disable_interrupts_hard();
-        extern void __enable_interrupts_hard();
-        static void __kernel_raw_rseq_register  (void) {
-                /* paranoid */ verify( __cfaabi_rseq.cpu_id == RSEQ_CPU_ID_UNINITIALIZED );
-                // int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), 0, (sigset_t *)0p, _NSIG / 8);
-                int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), 0, RSEQ_SIG);
-                if(ret != 0) {
-                        int e = errno;
-                        switch(e) {
-                        case EINVAL: abort("KERNEL ERROR: rseq register invalid argument");
-                        case ENOSYS: abort("KERNEL ERROR: rseq register no supported");
-                        case EFAULT: abort("KERNEL ERROR: rseq register with invalid argument");
-                        case EBUSY : abort("KERNEL ERROR: rseq register already registered");
-                        case EPERM : abort("KERNEL ERROR: rseq register sig  argument  on unregistration does not match the signature received on registration");
-                        default: abort("KERNEL ERROR: rseq register unexpected return %d", e);
+                        }
+                }
+        }
-        static void __kernel_raw_rseq_unregister(void) {
-                /* paranoid */ verify( __cfaabi_rseq.cpu_id >= 0 );
-                // int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), RSEQ_FLAG_UNREGISTER, (sigset_t *)0p, _NSIG / 8);
-                int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), RSEQ_FLAG_UNREGISTER, RSEQ_SIG);
-                if(ret != 0) {
-                        int e = errno;
-                        switch(e) {
-                        case EINVAL: abort("KERNEL ERROR: rseq unregister invalid argument");
-                        case ENOSYS: abort("KERNEL ERROR: rseq unregister no supported");
-                        case EFAULT: abort("KERNEL ERROR: rseq unregister with invalid argument");
-                        case EBUSY : abort("KERNEL ERROR: rseq unregister already registered");
-                        case EPERM : abort("KERNEL ERROR: rseq unregister sig  argument  on unregistration does not match the signature received on registration");
-                        default: abort("KERNEL ERROR: rseq unregisteunexpected return %d", e);
+                        }
+                }
+        }
-#else
-        // No definition needed
-#endif

libcfa/src/concurrency/kernel/cluster.hfa

-              r2ed94a9
+              rb110bcc
+}
 static struct {
         const unsigned readyq;
         const unsigned io;
+const static struct {
+        unsigned readyq;
+        unsigned io;
 } __shard_factor = { 2, 1 };

libcfa/src/concurrency/kernel/private.hfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 12 08:21:33 2020
 // Update Count     : 9
+// Last Modified On : Thu Mar  2 16:04:46 2023
+// Update Count     : 11
 //
 …
 extern "C" {
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        #include <rseq/rseq.h>
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        #include <linux/rseq.h>
-#else
-        #ifndef _GNU_SOURCE
-        #error kernel/private requires gnu_source
-        #endif
         #include <sched.h>
-#endif
+}
 …
 // Hardware
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No data needed
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        extern "Cforall" {
-                extern __attribute__((aligned(64))) __thread volatile struct rseq __cfaabi_rseq;
+        }
-#else
-        // No data needed
-#endif
 static inline int __kernel_getcpu() {
         /* paranoid */ verify( ! __preemption_enabled() );
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        return rseq_current_cpu();
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        int r = __cfaabi_rseq.cpu_id;
-        /* paranoid */ verify( r >= 0 );
-        return r;
-#else
         return sched_getcpu();
-#endif
+}

libcfa/src/concurrency/kernel/startup.cfa

-              r2ed94a9
+              rb110bcc
 #define __cforall_thread__
-#define _GNU_SOURCE
 // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
 // C Includes
 #include <errno.h>                                      // errno
+#include <errno.h>                                                                              // errno
 #include <signal.h>
 #include <string.h>                                     // strerror
 #include <unistd.h>                                     // sysconf
+#include <string.h>                                                                             // strerror
+#include <unistd.h>
+#include <limits.h>                                                                             // PTHREAD_STACK_MIN
 extern "C" {
+        #include <limits.h>                             // PTHREAD_STACK_MIN
+        #include <unistd.h>                             // syscall
+        #include <sys/eventfd.h>                        // eventfd
+        #include <sys/mman.h>                           // mprotect
+        #include <sys/resource.h>                       // getrlimit
+        #include <sys/eventfd.h>                                                        // eventfd
+        #include <sys/mman.h>                                                           // mprotect
+        #include <sys/resource.h>                                                       // getrlimit
+}
 …
 #include "kernel/private.hfa"
 #include "iofwd.hfa"
 #include "startup.hfa"                                  // STARTUP_PRIORITY_XXX
+#include "startup.hfa"                                                                  // STARTUP_PRIORITY_XXX
 #include "limits.hfa"
 #include "math.hfa"
 …
 __scheduler_RWLock_t __scheduler_lock @= { 0 };
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No data needed
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        extern "Cforall" {
-                __attribute__((aligned(64))) __thread volatile struct rseq __cfaabi_rseq @= {
-                        .cpu_id : RSEQ_CPU_ID_UNINITIALIZED,
-                };
+        }
-#else
-        // No data needed
-#endif
 //-----------------------------------------------------------------------------
 // Struct to steal stack

libcfa/src/concurrency/locks.cfa

r2ed94a9	rb110bcc
16	16
17	17	#define __cforall_thread__
18		~~#define _GNU_SOURCE~~
19	18
20	19	#include "locks.hfa"

libcfa/src/concurrency/locks.hfa

-              r2ed94a9
+              rb110bcc
 #include <fstream.hfa>
 // futex headers
 #include <linux/futex.h>      /* Definition of FUTEX_* constants */
 …
 // futex_mutex
-// - No cond var support
 // - Kernel thd blocking alternative to the spinlock
 // - No ownership (will deadlock on reacq)
 …
         int state;
+        // // linear backoff omitted for now
+        // for( int spin = 4; spin < 1024; spin += spin) {
+        //      state = 0;
+        //      // if unlocked, lock and return
+        //      if (internal_try_lock(this, state)) return;
+        //      if (2 == state) break;
+        //      for (int i = 0; i < spin; i++) Pause();
+        // }
+        // no contention try to acquire
+        if (internal_try_lock(this, state)) return;
+        for( int spin = 4; spin < 1024; spin += spin) {
+                state = 0;
+                // if unlocked, lock and return
+                if (internal_try_lock(this, state)) return;
+                if (2 == state) break;
+                for (int i = 0; i < spin; i++) Pause();
+        }
+        // // no contention try to acquire
+        // if (internal_try_lock(this, state)) return;
         // if not in contended state, set to be in contended state
 …
 static inline void unlock(futex_mutex & this) with(this) {
         // if uncontended do atomice unlock and then return
+        if (__atomic_fetch_sub(&val, 1, __ATOMIC_RELEASE) == 1) return; // TODO: try acq/rel
+        // if uncontended do atomic unlock and then return
+    if (__atomic_exchange_n(&val, 0, __ATOMIC_RELEASE) == 1) return;
         // otherwise threads are blocked so we must wake one
-        __atomic_store_n((int *)&val, 0, __ATOMIC_RELEASE);
         futex((int *)&val, FUTEX_WAKE, 1);
+}
 …
 // to set recursion count after getting signalled;
 static inline void on_wakeup( futex_mutex & f, size_t recursion ) {}
+//-----------------------------------------------------------------------------
+// go_mutex
+// - Kernel thd blocking alternative to the spinlock
+// - No ownership (will deadlock on reacq)
+// - Golang's flavour of mutex
+// - Impl taken from Golang: src/runtime/lock_futex.go
+struct go_mutex {
+        // lock state any state other than UNLOCKED is locked
+        // enum LockState { UNLOCKED = 0, LOCKED = 1, SLEEPING = 2 };
+        // stores a lock state
+        int val;
+};
+static inline void  ?{}( go_mutex & this ) with(this) { val = 0; }
+static inline bool internal_try_lock(go_mutex & this, int & compare_val, int new_val ) with(this) {
+        return __atomic_compare_exchange_n((int*)&val, (int*)&compare_val, new_val, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
+}
+static inline int internal_exchange(go_mutex & this, int swap ) with(this) {
+        return __atomic_exchange_n((int*)&val, swap, __ATOMIC_ACQUIRE);
+}
+// if this is called recursively IT WILL DEADLOCK!!!!!
+static inline void lock(go_mutex & this) with(this) {
+        int state, init_state;
+    // speculative grab
+    state = internal_exchange(this, 1);
+    if ( !state ) return; // state == 0
+    init_state = state;
+    for (;;) {
+        for( int i = 0; i < 4; i++ ) {
+            while( !val ) { // lock unlocked
+                state = 0;
+                if (internal_try_lock(this, state, init_state)) return;
+            }
+            for (int i = 0; i < 30; i++) Pause();
+        }
+        while( !val ) { // lock unlocked
+            state = 0;
+            if (internal_try_lock(this, state, init_state)) return;
+        }
+        sched_yield();
+        // if not in contended state, set to be in contended state
+        state = internal_exchange(this, 2);
+        if ( !state ) return; // state == 0
+        init_state = 2;
+        futex((int*)&val, FUTEX_WAIT, 2); // if val is not 2 this returns with EWOULDBLOCK
+    }
+}
+static inline void unlock( go_mutex & this ) with(this) {
+        // if uncontended do atomic unlock and then return
+    if (__atomic_exchange_n(&val, 0, __ATOMIC_RELEASE) == 1) return;
+        // otherwise threads are blocked so we must wake one
+        futex((int *)&val, FUTEX_WAKE, 1);
+}
+static inline void on_notify( go_mutex & f, thread$ * t){ unpark(t); }
+static inline size_t on_wait( go_mutex & f ) {unlock(f); return 0;}
+static inline void on_wakeup( go_mutex & f, size_t recursion ) {}
 //-----------------------------------------------------------------------------
 …
 static inline void on_wakeup(clh_lock & this, size_t recursion ) { lock(this); }
 //-----------------------------------------------------------------------------
 // Exponential backoff then block lock
 …
         this.lock_value = 0;
+}
+static inline void ^?{}( exp_backoff_then_block_lock & this ) {}
+// static inline void ?{}( exp_backoff_then_block_lock & this, exp_backoff_then_block_lock this2 ) = void;
+// static inline void ?=?( exp_backoff_then_block_lock & this, exp_backoff_then_block_lock this2 ) = void;
+static inline void  ^?{}( exp_backoff_then_block_lock & this ){}
 static inline bool internal_try_lock(exp_backoff_then_block_lock & this, size_t & compare_val) with(this) {
+        if (__atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
+                return true;
+        }
+        return false;
+        return __atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
+}
 …
 static inline bool try_lock_contention(exp_backoff_then_block_lock & this) with(this) {
+        if (__atomic_exchange_n(&lock_value, 2, __ATOMIC_ACQUIRE) == 0) {
+                return true;
+        }
+        return false;
+        return !__atomic_exchange_n(&lock_value, 2, __ATOMIC_ACQUIRE);
+}
 static inline bool block(exp_backoff_then_block_lock & this) with(this) {
+        lock( spinlock __cfaabi_dbg_ctx2 ); // TODO change to lockfree queue (MPSC)
         if (lock_value != 2) {
                 unlock( spinlock );
                 return true;
+        }
         insert_last( blocked_threads, *active_thread() );
         unlock( spinlock );
+    lock( spinlock __cfaabi_dbg_ctx2 );
+    if (__atomic_load_n( &lock_value, __ATOMIC_SEQ_CST) != 2) {
+        unlock( spinlock );
+        return true;
+    }
+    insert_last( blocked_threads, *active_thread() );
+    unlock( spinlock );
         park( );
         return true;
 …
         size_t compare_val = 0;
         int spin = 4;
         // linear backoff
         for( ;; ) {
 …
 static inline void unlock(exp_backoff_then_block_lock & this) with(this) {
     if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return;
         lock( spinlock __cfaabi_dbg_ctx2 );
         thread$ * t = &try_pop_front( blocked_threads );
         unlock( spinlock );
         unpark( t );
+    lock( spinlock __cfaabi_dbg_ctx2 );
+    thread$ * t = &try_pop_front( blocked_threads );
+    unlock( spinlock );
+    unpark( t );
+}

libcfa/src/concurrency/monitor.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:55:14 2019
 // Update Count     : 10
+// Last Modified On : Sun Feb 19 17:00:59 2023
+// Update Count     : 12
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "monitor.hfa"

libcfa/src/concurrency/mutex.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Fri May 25 01:37:11 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:16:39 2019
 // Update Count     : 1
+// Last Modified On : Sun Feb 19 17:01:36 2023
+// Update Count     : 3
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "mutex.hfa"

libcfa/src/concurrency/mutex_stmt.hfa

-              r2ed94a9
+              rb110bcc
+#pragma once
 #include "bits/algorithm.hfa"
 #include "bits/defs.hfa"
 …
 //-----------------------------------------------------------------------------
 // is_lock
+trait is_lock(L & | sized(L)) {
+forall(L & | sized(L))
+trait is_lock {
         // For acquiring a lock
         void lock( L & );
 …
     // Sort locks based on address
     __libcfa_small_sort(this.lockarr, count);
-    // acquire locks in order
-    // for ( size_t i = 0; i < count; i++ ) {
-    //     lock(*this.lockarr[i]);
-    // }
+}
-static inline void ^?{}( __mutex_stmt_lock_guard & this ) with(this) {
-    // for ( size_t i = count; i > 0; i-- ) {
-    //     unlock(*lockarr[i - 1]);
-    // }
+}

libcfa/src/concurrency/preemption.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 17 11:18:57 2022
 // Update Count     : 59
+// Last Modified On : Mon Jan  9 08:42:59 2023
+// Update Count     : 60
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 // #define __CFA_DEBUG_PRINT_PREEMPTION__

libcfa/src/concurrency/pthread.cfa

-              r2ed94a9
+              rb110bcc
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include <signal.h>
 …
 struct pthread_values{
         inline Seqable;
         void* value;
+        void * value;
         bool in_use;
 };
 …
 struct pthread_keys {
         bool in_use;
         void (*destructor)( void * );
+        void (* destructor)( void * );
         Sequence(pthread_values) threads;
 };
 static void ?{}(pthread_keys& k){
+static void ?{}(pthread_keys& k) {
         k.threads{};
+}
 …
 static pthread_keys cfa_pthread_keys_storage[PTHREAD_KEYS_MAX] __attribute__((aligned (16)));
 static void init_pthread_storage(){
         for (int i = 0; i < PTHREAD_KEYS_MAX; i++){
+static void init_pthread_storage() {
+        for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
                 cfa_pthread_keys_storage[i]{};
+        }
 …
 /* condvar helper routines */
 static void init(pthread_cond_t* pcond){
+static void init(pthread_cond_t * pcond) {
         static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
         cfa2pthr_cond_var_t* _cond = (cfa2pthr_cond_var_t*)pcond;
+        cfa2pthr_cond_var_t * _cond = (cfa2pthr_cond_var_t *)pcond;
         ?{}(*_cond);
+}
 static cfa2pthr_cond_var_t* get(pthread_cond_t* pcond){
+static cfa2pthr_cond_var_t * get(pthread_cond_t * pcond) {
         static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
         return (cfa2pthr_cond_var_t*)pcond;
+}
 static void destroy(pthread_cond_t* cond){
+        return (cfa2pthr_cond_var_t *)pcond;
+}
+static void destroy(pthread_cond_t * cond) {
         static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
         ^?{}(*get(cond));
 …
 /* mutex helper routines */
 static void mutex_check(pthread_mutex_t* t){
+static void mutex_check(pthread_mutex_t * t) {
         // Use double check to improve performance.
         // Check is safe on x86; volatile prevents compiler reordering
         volatile pthread_mutex_t *const mutex_ = t;
+        volatile pthread_mutex_t * const mutex_ = t;
         // SKULLDUGGERY: not a portable way to access the kind field, /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h
 …
 static void init(pthread_mutex_t* plock){
+static void init(pthread_mutex_t * plock) {
         static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
         simple_owner_lock* _lock = (simple_owner_lock*)plock;
+        simple_owner_lock * _lock = (simple_owner_lock *)plock;
         ?{}(*_lock);
+}
 static simple_owner_lock* get(pthread_mutex_t* plock){
+static simple_owner_lock * get(pthread_mutex_t * plock) {
         static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
         return (simple_owner_lock*)plock;
+}
 static void destroy(pthread_mutex_t* plock){
+        return (simple_owner_lock *)plock;
+}
+static void destroy(pthread_mutex_t * plock) {
         static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
         ^?{}(*get(plock));
 …
 //######################### Attr helpers #########################
 struct cfaPthread_attr_t {                                                              // thread attributes
+typedef struct cfaPthread_attr_t {                                              // thread attributes
                 int contentionscope;
                 int detachstate;
                 size_t stacksize;
                 void *stackaddr;
+                void * stackaddr;
                 int policy;
                 int inheritsched;
                 struct sched_param param;
 } typedef cfaPthread_attr_t;
 static const cfaPthread_attr_t default_attrs{
+} cfaPthread_attr_t;
+static const cfaPthread_attr_t default_attrs {
 ,
 ,
         (size_t)65000,
         (void *)NULL,
+_000,
+        NULL,
 ,
 ,
 …
 };
 static cfaPthread_attr_t* get(const pthread_attr_t* attr){
         static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t),"sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
         return (cfaPthread_attr_t*)attr;
+static cfaPthread_attr_t * get(const pthread_attr_t * attr) {
+        static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t), "sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
+        return (cfaPthread_attr_t *)attr;
+}
 …
         // pthreads return value
         void *joinval;
+        void * joinval;
         // pthread attributes
         pthread_attr_t pthread_attr;
         void *(*start_routine)(void *);
         void *start_arg;
+        void *(* start_routine)(void *);
+        void * start_arg;
         // thread local data
         pthread_values* pthreadData;
+        pthread_values * pthreadData;
         // flag used for tryjoin
 …
 /* thread part routines */
 //  cfaPthread entry point
 void main(cfaPthread& _thread) with(_thread){
         joinval =  start_routine(start_arg);
+void main(cfaPthread & _thread) with(_thread) {
+        joinval = start_routine(start_arg);
         isTerminated = true;
+}
 static cfaPthread *lookup( pthread_t p ){
         static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*),"sizeof(pthread_t) < sizeof(cfaPthread*)");
         return (cfaPthread*)p;
+}
 static void pthread_deletespecific_( pthread_values* values )  { // see uMachContext::invokeTask
         pthread_values* value;
         pthread_keys* key;
+static cfaPthread * lookup( pthread_t p ) {
+        static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *),"sizeof(pthread_t) < sizeof(cfaPthread *)");
+        return (cfaPthread *)p;
+}
+static void pthread_deletespecific_( pthread_values * values )  { // see uMachContext::invokeTask
+        pthread_values * value;
+        pthread_keys * key;
         bool destcalled = true;
         if (values != NULL){
+        if (values != NULL) {
                 for ( int attempts = 0; attempts < PTHREAD_DESTRUCTOR_ITERATIONS && destcalled ; attempts += 1 ) {
                         destcalled = false;
                         lock(key_lock);
                         for (int i = 0; i < PTHREAD_KEYS_MAX; i++){
+                        for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
                                 // for each valid key
                                 if ( values[i].in_use){
+                                if ( values[i].in_use) {
                                         value = &values[i];
                                         key = &cfa_pthread_keys[i];
 …
                                         // if  a  key  value  has  a  non-NULL  destructor pointer,  and  the  thread  has  a  non-NULL  value associated with that key,
                                         // the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument.
                                         if (value->value != NULL && key->destructor != NULL){
+                                        if (value->value != NULL && key->destructor != NULL) {
                                                 unlock(key_lock);
                                                 key->destructor(value->value); // run destructor
 …
+}
 static void ^?{}(cfaPthread & mutex t){
+static void ^?{}(cfaPthread & mutex t) {
         // delete pthread local storage
         pthread_values * values = t.pthreadData;
 …
+}
 static void ?{}(cfaPthread &t, pthread_t* _thread, const pthread_attr_t * _attr,void *(*start_routine)(void *), void * arg) {
         static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread*)");
+static void ?{}(cfaPthread & t, pthread_t * _thread, const pthread_attr_t * _attr,void *(* start_routine)(void *), void * arg) {
+        static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread *)");
         // set up user thread stackSize
 …
         //######################### Pthread Attrs #########################
         int pthread_attr_init(pthread_attr_t *attr) libcfa_public __THROW {
                 cfaPthread_attr_t* _attr = get(attr);
+        int pthread_attr_init(pthread_attr_t * attr) libcfa_public __THROW {
+                cfaPthread_attr_t * _attr = get(attr);
                 ?{}(*_attr, default_attrs);
                 return 0;
+        }
         int pthread_attr_destroy(pthread_attr_t *attr) libcfa_public __THROW {
+        int pthread_attr_destroy(pthread_attr_t * attr) libcfa_public __THROW {
                 ^?{}(*get(attr));
                 return 0;
+        }
         int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) libcfa_public __THROW {
+        int pthread_attr_setscope( pthread_attr_t * attr, int contentionscope ) libcfa_public __THROW {
                 get( attr )->contentionscope = contentionscope;
                 return 0;
         } // pthread_attr_setscope
         int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) libcfa_public __THROW {
+        int pthread_attr_getscope( const pthread_attr_t * attr, int * contentionscope ) libcfa_public __THROW {
                 *contentionscope = get( attr )->contentionscope;
                 return 0;
         } // pthread_attr_getscope
         int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) libcfa_public __THROW {
+        int pthread_attr_setdetachstate( pthread_attr_t * attr, int detachstate ) libcfa_public __THROW {
                 get( attr )->detachstate = detachstate;
                 return 0;
         } // pthread_attr_setdetachstate
         int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) libcfa_public __THROW {
+        int pthread_attr_getdetachstate( const pthread_attr_t * attr, int * detachstate ) libcfa_public __THROW {
                 *detachstate = get( attr )->detachstate;
                 return 0;
         } // pthread_attr_getdetachstate
         int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) libcfa_public __THROW {
+        int pthread_attr_setstacksize( pthread_attr_t * attr, size_t stacksize ) libcfa_public __THROW {
                 get( attr )->stacksize = stacksize;
                 return 0;
         } // pthread_attr_setstacksize
         int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) libcfa_public __THROW {
+        int pthread_attr_getstacksize( const pthread_attr_t * attr, size_t * stacksize ) libcfa_public __THROW {
                 *stacksize = get( attr )->stacksize;
                 return 0;
 …
         } // pthread_attr_setguardsize
         int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) libcfa_public __THROW {
+        int pthread_attr_setstackaddr( pthread_attr_t * attr, void * stackaddr ) libcfa_public __THROW {
                 get( attr )->stackaddr = stackaddr;
                 return 0;
         } // pthread_attr_setstackaddr
         int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) libcfa_public __THROW {
+        int pthread_attr_getstackaddr( const pthread_attr_t * attr, void ** stackaddr ) libcfa_public __THROW {
                 *stackaddr = get( attr )->stackaddr;
                 return 0;
         } // pthread_attr_getstackaddr
         int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) libcfa_public __THROW {
+        int pthread_attr_setstack( pthread_attr_t * attr, void * stackaddr, size_t stacksize ) libcfa_public __THROW {
                 get( attr )->stackaddr = stackaddr;
                 get( attr )->stacksize = stacksize;
 …
         } // pthread_attr_setstack
         int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) libcfa_public __THROW {
+        int pthread_attr_getstack( const pthread_attr_t * attr, void ** stackaddr, size_t * stacksize ) libcfa_public __THROW {
                 *stackaddr = get( attr )->stackaddr;
                 *stacksize = get( attr )->stacksize;
 …
         // already running thread threadID. It shall be called on unitialized attr
         // and destroyed with pthread_attr_destroy when no longer needed.
         int pthread_getattr_np( pthread_t threadID, pthread_attr_t *attr ) libcfa_public __THROW { // GNU extension
+        int pthread_getattr_np( pthread_t threadID, pthread_attr_t * attr ) libcfa_public __THROW { // GNU extension
                 check_nonnull(attr);
 …
         //######################### Threads #########################
         int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(*start_routine)(void *), void * arg) libcfa_public __THROW {
                 cfaPthread *t = alloc();
+        int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(* start_routine)(void *), void * arg) libcfa_public __THROW {
+                cfaPthread * t = alloc();
                 (*t){_thread, attr, start_routine, arg};
                 return 0;
+        }
+        int pthread_join(pthread_t _thread, void **value_ptr) libcfa_public __THROW {
+        int pthread_join(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
                 // if thread is invalid
                 if (_thread == NULL) return EINVAL;
 …
                 // get user thr pointer
                 cfaPthread* p = lookup(_thread);
+                cfaPthread * p = lookup(_thread);
                 try {
                         join(*p);
 …
+        }
         int pthread_tryjoin_np(pthread_t _thread, void **value_ptr) libcfa_public __THROW {
+        int pthread_tryjoin_np(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
                 // if thread is invalid
                 if (_thread == NULL) return EINVAL;
                 if (_thread == pthread_self()) return EDEADLK;
                 cfaPthread* p = lookup(_thread);
+                cfaPthread * p = lookup(_thread);
                 // thread not finished ?
 …
         void pthread_exit(void * status) libcfa_public __THROW {
                 pthread_t pid = pthread_self();
                 cfaPthread* _thread = (cfaPthread*)pid;
+                cfaPthread * _thread = (cfaPthread *)pid;
                 _thread->joinval = status;  // set return value
                 _thread->isTerminated = 1;  // set terminated flag
 …
         //######################### Mutex #########################
         int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr) libcfa_public __THROW {
+        int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t * attr) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 init(_mutex);
 …
         int pthread_mutex_destroy(pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
                 if (_lock->owner != NULL){
+                simple_owner_lock * _lock = get(_mutex);
+                if (_lock->owner != NULL) {
                         return EBUSY;
+                }
 …
                 check_nonnull(_mutex);
                 mutex_check(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
+                simple_owner_lock * _lock = get(_mutex);
                 lock(*_lock);
                 return 0;
 …
         int pthread_mutex_unlock(pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
                 if (_lock->owner != active_thread()){
+                simple_owner_lock * _lock = get(_mutex);
+                if (_lock->owner != active_thread()) {
                         return EPERM;
                 } // current thread does not hold the mutex
 …
         int pthread_mutex_trylock(pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
                 if (_lock->owner != active_thread() && _lock->owner != NULL){
+                simple_owner_lock * _lock = get(_mutex);
+                if (_lock->owner != active_thread() && _lock->owner != NULL) {
                         return EBUSY;
                 }   // if mutex is owned
 …
         /* conditional variable routines */
         int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) libcfa_public __THROW {
+        int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr) libcfa_public __THROW {
                 check_nonnull(cond);
                 init(cond);
 …
         }  //pthread_cond_init
         int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
+        int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 check_nonnull(cond);
 …
         } // pthread_cond_timedwait
         int pthread_cond_signal(pthread_cond_t *cond) libcfa_public __THROW {
+        int pthread_cond_signal(pthread_cond_t * cond) libcfa_public __THROW {
                 check_nonnull(cond);
                 return notify_one(*get(cond));
         } // pthread_cond_signal
         int pthread_cond_broadcast(pthread_cond_t *cond) libcfa_public __THROW {
+        int pthread_cond_broadcast(pthread_cond_t * cond) libcfa_public __THROW {
                 check_nonnull(cond);
                 return notify_all(*get(cond));
         } // pthread_cond_broadcast
         int pthread_cond_destroy(pthread_cond_t *cond) libcfa_public __THROW {
+        int pthread_cond_destroy(pthread_cond_t * cond) libcfa_public __THROW {
                 check_nonnull(cond);
                 destroy(cond);
 …
         //######################### Local storage #########################
         int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) libcfa_public __THROW {
+        int pthread_once(pthread_once_t * once_control, void (* init_routine)(void)) libcfa_public __THROW {
                 static_assert(sizeof(pthread_once_t) >= sizeof(int),"sizeof(pthread_once_t) < sizeof(int)");
                 check_nonnull(once_control);
 …
         } // pthread_once
         int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) libcfa_public __THROW {
+        int pthread_key_create( pthread_key_t * key, void (* destructor)( void * ) ) libcfa_public __THROW {
                 lock(key_lock);
                 for ( int i = 0; i < PTHREAD_KEYS_MAX; i += 1 ) {
 …
         }   // pthread_key_delete
         int pthread_setspecific( pthread_key_t key, const void *value ) libcfa_public __THROW {
+        int pthread_setspecific( pthread_key_t key, const void * value ) libcfa_public __THROW {
                 // get current thread
                 cfaPthread* t = lookup(pthread_self());
+                cfaPthread * t = lookup(pthread_self());
                 // if current thread's pthreadData is NULL; initialize it
                 pthread_values* values;
                 if (t->pthreadData == NULL){
+                pthread_values * values;
+                if (t->pthreadData == NULL) {
                         values = anew( PTHREAD_KEYS_MAX);
                         t->pthreadData = values;
                         for (int i = 0;i < PTHREAD_KEYS_MAX; i++){
+                        for ( int i = 0;i < PTHREAD_KEYS_MAX; i++ ) {
                                 t->pthreadData[i].in_use = false;
                         }   // for
 …
         } //pthread_setspecific
         void* pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
+        void * pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
                 if (key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use) return NULL;
                 // get current thread
                 cfaPthread* t = lookup(pthread_self());
+                cfaPthread * t = lookup(pthread_self());
                 if (t->pthreadData == NULL) return NULL;
                 lock(key_lock);
                 pthread_values &entry = ((pthread_values *)t->pthreadData)[key];
+                pthread_values & entry = ((pthread_values *)t->pthreadData)[key];
                 if ( ! entry.in_use ) {
                         unlock( key_lock );
                         return NULL;
                 } // if
                 void *value = entry.value;
+                void * value = entry.value;
                 unlock(key_lock);
 …
         //######################### Parallelism #########################
         int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_setaffinity_np" );
         } // pthread_setaffinity_np
         int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_getaffinity_np" );
         } // pthread_getaffinity_np
         int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_attr_setaffinity_np" );
         } // pthread_attr_setaffinity_np
         int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_attr_getaffinity_np" );
         } // pthread_attr_getaffinity_np
+        // int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_setaffinity_np" );
+        // } // pthread_setaffinity_np
+        // int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_getaffinity_np" );
+        // } // pthread_getaffinity_np
+        // int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_attr_setaffinity_np" );
+        // } // pthread_attr_setaffinity_np
+        // int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_attr_getaffinity_np" );
+        // } // pthread_attr_getaffinity_np
         //######################### Cancellation #########################
 …
         } // pthread_cancel
         int pthread_setcancelstate( int state, int *oldstate ) libcfa_public __THROW {
+        int pthread_setcancelstate( int state, int * oldstate ) libcfa_public __THROW {
                 abort("pthread_setcancelstate not implemented");
                 return 0;
         } // pthread_setcancelstate
         int pthread_setcanceltype( int type, int *oldtype ) libcfa_public __THROW {
+        int pthread_setcanceltype( int type, int * oldtype ) libcfa_public __THROW {
                 abort("pthread_setcanceltype not implemented");
                 return 0;
 …
 #pragma GCC diagnostic pop

libcfa/src/concurrency/ready_queue.cfa

r2ed94a9	rb110bcc
15	15
16	16	#define __cforall_thread__
17		~~#define _GNU_SOURCE~~
18	17
19	18	// #define __CFA_DEBUG_PRINT_READY_QUEUE__

libcfa/src/concurrency/select.hfa

r2ed94a9	rb110bcc
	1	#pragma once
	2
1	3	#include "containers/list.hfa"
2	4	#include <stdint.h>

libcfa/src/concurrency/thread.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 11 20:56:54 2022
 // Update Count     : 102
+// Last Modified On : Mon Jan  9 08:42:33 2023
+// Update Count     : 103
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "thread.hfa"

libcfa/src/containers/array.hfa

-              r2ed94a9
+              rb110bcc
+//
+// Single-dim array sruct (with explicit packing and atom)
+//
+//
+// The `array` macro is the public interface.
+// It computes the type of a dense (trivially strided) array.
+// All user-declared objects are dense arrays.
+//
+// The `arpk` (ARray with PacKing info explicit) type is, generally, a slice with _any_ striding.
+// This type is meant for internal use.
+// CFA programmers should not instantiate it directly, nor access its field.
+// CFA programmers should call ?[?] on it.
+// Yet user-given `array(stuff)` expands to `arpk(stuff')`.
+// The comments here explain the resulting internals.
+//
+// Just as a plain-C "multidimesional" array is really array-of-array-of-...,
+// so does arpk generally show up as arpk-of-arpk-of...
+//
+// In the example of `array(float, 3, 4, 5) a;`,
+// `typeof(a)` is an `arpk` instantiation.
+// These comments explain _its_ arguments, i.e. those of the topmost `arpk` level.
+//
+// [N]    : the number of elements in `a`; 3 in the example
+// S      : carries the stride size (distance in bytes between &myA[0] and &myA[1]), in sizeof(S);
+//          same as Timmed when striding is trivial, same as Timmed in the example
+// Timmed : (T-immediate) the inner type; conceptually, `typeof(a)` is "arpk of Timmed";
+//          array(float, 4, 5) in the example
+// Tbase  : (T-base) the deepest element type that is not arpk; float in the example
+//
 forall( [N], S & | sized(S), Timmed &, Tbase & ) {
+    //
+    // Single-dim array sruct (with explicit packing and atom)
+    //
     struct arpk {
         S strides[N];

libcfa/src/containers/list.hfa

-              r2ed94a9
+              rb110bcc
 static inline tytagref(void, T) ?`inner ( T & this ) { tytagref( void, T ) ret = {this}; return ret; }
+// use this on every case of plan-9 inheritance, to make embedded a closure of plan-9 inheritance
+#define P9_EMBEDDED( derived, immedBase ) \
+forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
+    static inline tytagref(immedBase, Tbase) ?`inner( derived & this ) { \
+//
+// P9_EMBEDDED: Use on every case of plan-9 inheritance, to make "implements embedded" be a closure of plan-9 inheritance.
+//
+// struct foo {
+//    int a, b, c;
+//    inline (bar);
+// };
+// P9_EMBEDDED( foo, bar )
+//
+// usual version, for structs that are top-level declarations
+#define P9_EMBEDDED(        derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) P9_EMBEDDED_BDY_( immedBase )
+// special version, for structs that are declared in functions
+#define P9_EMBEDDED_INFUNC( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase,        ) P9_EMBEDDED_BDY_( immedBase )
+// forward declarations of both the above; generally not needed
+// may help you control where the P9_EMBEEDED cruft goes, in case "right after the stuct" isn't where you want it
+#define P9_EMBEDDED_FWD(        derived, immedBase )      P9_EMBEDDED_DECL_( derived, immedBase, static ) ;
+#define P9_EMBEDDED_FWD_INFUNC( derived, immedBase ) auto P9_EMBEDDED_DECL_( derived, immedBase,        ) ;
+// private helpers
+#define P9_EMBEDDED_DECL_( derived, immedBase, STORAGE ) \
+    forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
+    STORAGE inline tytagref(immedBase, Tbase) ?`inner( derived & this )
+#define P9_EMBEDDED_BDY_( immedBase ) { \
         immedBase & ib = this; \
         Tbase & b = ib`inner; \

libcfa/src/containers/vector2.hfa

-              r2ed94a9
+              rb110bcc
 // Author           : Michael Brooks
 // Created On       : Thu Jun 23 22:00:00 2021
+// Last Modified By : Michael Brooks
+// Last Modified On : Thu Jun 23 22:00:00 2021
+// Update Count     : 1
+//
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Mar 14 08:40:53 2023
+// Update Count     : 2
+//
+#pragma once
 #include <stdlib.hfa>

libcfa/src/interpose.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jan  5 22:23:57 2023
+// Update Count     : 180
+//
+#include <stdarg.h>                                                                             // va_start, va_end
+// Last Modified On : Mon Mar 27 21:09:03 2023
+// Update Count     : 196
+//
 #include <stdio.h>
-#include <string.h>                                                                             // strlen
 #include <unistd.h>                                                                             // _exit, getpid
-#include <signal.h>
 extern "C" {
 #include <dlfcn.h>                                                                              // dlopen, dlsym
 …
+}
-#include "bits/debug.hfa"
 #include "bits/defs.hfa"
 #include "bits/signal.hfa"                                                              // sigHandler_?
 …
 typedef void (* generic_fptr_t)(void);
 static generic_fptr_t do_interpose_symbol( void * library, const char symbol[], const char version[] ) {
-        const char * error;
         union { generic_fptr_t fptr; void * ptr; } originalFunc;
         #if defined( _GNU_SOURCE )
                 if ( version ) {
                         originalFunc.ptr = dlvsym( library, symbol, version );
                 } else {
                         originalFunc.ptr = dlsym( library, symbol );
+                }
+        if ( version ) {
+                originalFunc.ptr = dlvsym( library, symbol, version );
+        } else {
+                originalFunc.ptr = dlsym( library, symbol );
+        } // if
         #else
                 originalFunc.ptr = dlsym( library, symbol );
+        originalFunc.ptr = dlsym( library, symbol );
         #endif // _GNU_SOURCE
         error = dlerror();
         if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
+        if ( ! originalFunc.ptr ) {                                                     // == nullptr
+                abort( "interpose_symbol : internal error, %s\n", dlerror() );
+        } // if
         return originalFunc.fptr;
+}
 static generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
+        const char * error;
+        static void * library;
+        static void * pthread_library;
+        if ( ! library ) {
+                #if defined( RTLD_NEXT )
+                        library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        library = dlopen( "libc.so.6", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libc, %s\n", error );
+                        }
+                #endif
+        void * library;
+        #if defined( RTLD_NEXT )
+        library = RTLD_NEXT;
+        #else
+        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+        library = dlopen( "libc.so.6", RTLD_LAZY );
+        if ( ! library ) {                                                                      // == nullptr
+                abort( "interpose_symbol : failed to open libc, %s\n", dlerror() );
         } // if
+        if ( ! pthread_library ) {
+                #if defined( RTLD_NEXT )
+                        pthread_library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        pthread_library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        } // if
+        return do_interpose_symbol(library, symbol, version);
+        #endif // RTLD_NEXT
+        return do_interpose_symbol( library, symbol, version );
+}
 …
                 preload_libgcc();
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
                 INTERPOSE_LIBC( abort, version );
                 INTERPOSE_LIBC( exit , version );
 #pragma GCC diagnostic pop
+                #pragma GCC diagnostic pop
                 if(__cfathreadabi_interpose_startup) __cfathreadabi_interpose_startup( do_interpose_symbol );
+                // SKULLDUGGERY: In Ubuntu 22.04, someone augmented signal.h to allow SIGSTKSZ to be "sysconf(_SC_SIGSTKSZ)" in
+                // sigstksz.h, as well as 8192 in sigstack.h. HOWEVER, they forgot to provide a mechanism to tell signal.h to
+                // use sigstack.h rather than sigstksz.h. (I'm not happy.) By undefining _GNU_SOURCE before signal.h and
+                // redefining it afterwards, you can get 8192, but then nothing works correctly inside of signal.h without
+                // _GNU_SOURCE defined.  So what is needed is a way to get signal.h to use sigstack.h WITH _GNU_SOURCE defined.
+                // Basically something is wrong with features.h and its use in signal.h.
+                #undef SIGSTKSZ
+                #define SIGSTKSZ 8192
                 // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because
 …
         va_start( args, fmt );
         __abort( false, fmt, args );
     // CONTROL NEVER REACHES HERE!
+        // CONTROL NEVER REACHES HERE!
         va_end( args );
+}
 void abort( bool signalAbort, const char fmt[], ... ) {
     va_list args;
     va_start( args, fmt );
     __abort( signalAbort, fmt, args );
     // CONTROL NEVER REACHES HERE!
     va_end( args );
+        va_list args;
+        va_start( args, fmt );
+        __abort( signalAbort, fmt, args );
+        // CONTROL NEVER REACHES HERE!
+        va_end( args );
+}

libcfa/src/interpose_thread.cfa

-              r2ed94a9
+              rb110bcc
 //
+#include <stdarg.h>                                                                             // va_start, va_end
+#include <stdio.h>
+#include <string.h>                                                                             // strlen
+// BUG in 32-bit gcc with interpose: fixed in >= gcc-9.5, gcc-10.4, gcc-12.2
+#ifdef __i386__                                                                                 // 32-bit architecture
+#undef _GNU_SOURCE
+#endif // __i386__
 #include <signal.h>
 #include <pthread.h>
+#include <signal.h>
 extern "C" {
 #include <dlfcn.h>                                                                              // dlopen, dlsym
-#include <execinfo.h>                                                                   // backtrace, messages
+}
-#include "bits/debug.hfa"
 #include "bits/defs.hfa"
-#include <assert.h>
 //=============================================================================================
 …
 typedef void (* generic_fptr_t)(void);
 generic_fptr_t interpose_symbol(
+generic_fptr_t libcfa_public interpose_symbol(
         generic_fptr_t (*do_interpose_symbol)( void * library, const char symbol[], const char version[] ),
         const char symbol[],
         const char version[]
 ) libcfa_public {
         const char * error;
+) {
+        void * library;
+        static void * library;
+        if ( ! library ) {
+                #if defined( RTLD_NEXT )
+                        library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        #if defined( RTLD_NEXT )
+        library = RTLD_NEXT;
+        #else
+        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+        library = dlopen( "libpthread.so", RTLD_LAZY );
+        if ( ! library ) {                                                                      // == nullptr
+                abort( "interpose_symbol : failed to open libpthread, %s\n", dlerror() );
         } // if
+        #endif // RTLD_NEXT
         return do_interpose_symbol(library, symbol, version);
+        return do_interpose_symbol( library, symbol, version );
+}
 …
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
                 INTERPOSE( pthread_create , version );
                 INTERPOSE( pthread_join , version );
                 INTERPOSE( pthread_self , version );
                 INTERPOSE( pthread_attr_init , version );
                 INTERPOSE( pthread_attr_destroy , version );
                 INTERPOSE( pthread_attr_setstack , version );
                 INTERPOSE( pthread_attr_getstacksize , version );
                 INTERPOSE( pthread_sigmask , version );
                 INTERPOSE( pthread_sigqueue , version );
                 INTERPOSE( pthread_once , version );
+                INTERPOSE( pthread_create, version );
+                INTERPOSE( pthread_join, version );
+                INTERPOSE( pthread_self, version );
+                INTERPOSE( pthread_attr_init, version );
+                INTERPOSE( pthread_attr_destroy, version );
+                INTERPOSE( pthread_attr_setstack, version );
+                INTERPOSE( pthread_attr_getstacksize, version );
+                INTERPOSE( pthread_sigmask, version );
+                INTERPOSE( pthread_sigqueue, version );
+                INTERPOSE( pthread_once, version );
 #pragma GCC diagnostic pop
+        }

libcfa/src/iostream.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 27 15:04:15 2022
 // Update Count     : 1358
+// Last Modified On : Mon Jan  9 09:27:58 2023
+// Update Count     : 1361
 //
 …
                         } /* if */ \
                         if ( ! f.flags.nobsdp || (exp10 < SUFFIXES_START) || (exp10 > SUFFIXES_END) ) { \
                                 len2 = snprintf( &buf[len], size - len, "e%d", exp10 ); \
+                                len2 = snprintf( &buf[len], size - len, "e%d", (int)exp10 /* ambiguity with function exp10 */ ); \
                         } else { \
                                 len2 = snprintf( &buf[len], size - len, "%s", suffixes[(exp10 - SUFFIXES_START) / 3] ); \

libcfa/src/limits.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed Apr  6 18:06:52 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan  5 22:27:40 2023
 // Update Count     : 84
+// Last Modified On : Fri Feb 17 12:25:39 2023
+// Update Count     : 87
 //
-#define _GNU_SOURCE                                                                             // access long double M_*l in math.h
 #include <limits.h>
 #include <float.h>

libcfa/src/stdlib.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec  9 15:11:30 2022
 // Update Count     : 631
+// Last Modified On : Thu Feb 16 16:31:34 2023
+// Update Count     : 633
 //
 …
 //---------------------------------------
-#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <string.h>                                                                             // memcpy, memset
 //#include <math.h>                                                                             // fabsf, fabs, fabsl

libcfa/src/vec/vec.hfa

-              r2ed94a9
+              rb110bcc
 #include <math.hfa>
+trait fromint(T) {
+forall(T)
+trait fromint {
     void ?{}(T&, int);
 };
+trait zeroinit(T) {
+forall(T)
+trait zeroinit {
     void ?{}(T&, zero_t);
 };
+trait zero_assign(T) {
+forall(T)
+trait zero_assign {
     T ?=?(T&, zero_t);
 };
+trait subtract(T) {
+forall(T)
+trait subtract {
     T ?-?(T, T);
 };
+trait negate(T) {
+forall(T)
+trait negate {
     T -?(T);
 };
+trait add(T) {
+forall(T)
+trait add {
     T ?+?(T, T);
 };
+trait multiply(T) {
+forall(T)
+trait multiply {
     T ?*?(T, T);
 };
+trait divide(T) {
+forall(T)
+trait divide {
     T ?/?(T, T);
 };
+trait lessthan(T) {
+forall(T)
+trait lessthan {
     int ?<?(T, T);
 };
+trait equality(T) {
+forall(T)
+trait equality {
     int ?==?(T, T);
 };
+trait sqrt(T) {
+forall(T)
+trait sqrt {
     T sqrt(T);
 };

src/AST/Attribute.hpp

r2ed94a9	rb110bcc
27	27	class Expr;
28	28
	29	/// An entry in an attribute list: `__attribute__(( ... ))`
29	30	class Attribute final : public Node {
30	31	public:

src/AST/Convert.cpp

-              r2ed94a9
+              rb110bcc
                 auto stmt = new SuspendStmt();
                 stmt->then   = get<CompoundStmt>().accept1( node->then   );
                 switch(node->type) {
+                switch (node->kind) {
                         case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
                         case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
 …
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
                         old->type->isVarArgs
+                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
                 };
 …
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
                         old->isDoWhile,
+                        (old->isDoWhile) ? ast::DoWhile : ast::While,
                         GET_LABELS_V(old->labels)
                 );
 …
         virtual void visit( const SuspendStmt * old ) override final {
                 if ( inCache( old ) ) return;
                 ast::SuspendStmt::Type type;
+                ast::SuspendStmt::Kind type;
                 switch (old->type) {
                         case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;

src/AST/Create.cpp

r2ed94a9	rb110bcc
20	20	#include "AST/Decl.hpp"
21	21	#include "AST/Type.hpp"
	22	#include "Common/Iterate.hpp"
22	23
23	24	namespace ast {

src/AST/Decl.cpp

-              r2ed94a9
+              rb110bcc
 #include <unordered_map>
 #include "Common/utility.h"
+#include "Common/Eval.h"       // for eval
 #include "Fwd.hpp"             // for UniqueId
 …
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
         std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ),
         type_params(std::move(forall)), assertions(),
         params(std::move(params)), returns(std::move(returns)), stmts( stmts ) {
         FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        FunctionType * ftype = new FunctionType( isVarArgs );
         for (auto & param : this->params) {
                 ftype->params.emplace_back(param->get_type());
 …
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
         std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
                 type_params( std::move( forall) ), assertions( std::move( assertions ) ),
                 params( std::move(params) ), returns( std::move(returns) ),
                 type( nullptr ), stmts( stmts ) {
         FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        FunctionType * type = new FunctionType( isVarArgs );
         for ( auto & param : this->params ) {
                 type->params.emplace_back( param->get_type() );

src/AST/Decl.hpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Nov 24  9:44:00 2022
 // Update Count     : 34
+// Last Modified On : Wed Apr  5 10:42:00 2023
+// Update Count     : 35
 //
 …
 };
+/// Function variable arguments flag
+enum ArgumentFlag { FixedArgs, VariableArgs };
 /// Object declaration `int foo()`
 class FunctionDecl : public DeclWithType {
 …
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
         FunctionDecl( const CodeLocation & location, const std::string & name,
 …
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
         const Type * get_type() const override;
 …
 public:
         bool isTyped; // isTyped indicated if the enum has a declaration like:
         // enum (type_optional) Name {...}
+        // enum (type_optional) Name {...}
         ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
         enum class EnumHiding { Visible, Hide } hide;
 …
 };
+/// Assembly declaration: `asm ... ( "..." : ... )`
 class AsmDecl : public Decl {
 public:

src/AST/Expr.hpp

-              r2ed94a9
+              rb110bcc
 };
+/// A name qualified by a namespace or type.
 class QualifiedNameExpr final : public Expr {
 public:
 …
         std::string name;
         QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n )
+        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n )
         : Expr( loc ), type_decl( d ), name( n ) {}
 …
 };
+/// A name that refers to a generic dimension parameter.
 class DimensionExpr final : public Expr {
 public:
 …
 };
+}

src/AST/Fwd.hpp

-              r2ed94a9
+              rb110bcc
 #pragma once
+template<typename> struct bitfield;
 #include "AST/Node.hpp"
 …
 class TranslationGlobal;
+// For the following types, only use the using type.
+namespace CV {
+        struct qualifier_flags;
+        using Qualifiers = bitfield<qualifier_flags>;
+}
+namespace Function {
+        struct spec_flags;
+        using Specs = bitfield<spec_flags>;
+}
+namespace Storage {
+        struct class_flags;
+        using Classes = bitfield<class_flags>;
+}
+namespace Linkage {
+        struct spec_flags;
+        using Spec = bitfield<spec_flags>;
+}
+}

src/AST/Init.hpp

r2ed94a9	rb110bcc
117	117	ptr<Init> init;
118	118
119		ConstructorInit(
	119	ConstructorInit(
120	120	const CodeLocation & loc, const Stmt * ctor, const Stmt * dtor, const Init * init )
121	121	: Init( loc, MaybeConstruct ), ctor( ctor ), dtor( dtor ), init( init ) {}

src/AST/Inspect.cpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Oct  3 11:04:00 2022
 // Update Count     : 3
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 4
 //
 …
+}
+bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+        return obj && obj->name.empty() && obj->bitfieldWidth;
+}
 } // namespace ast

src/AST/Inspect.hpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Sep 22 13:44:00 2022
 // Update Count     : 2
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 3
 //
 …
 const ApplicationExpr * isIntrinsicCallExpr( const Expr * expr );
+/// Returns true if obj's name is the empty string and it has a bitfield width.
+bool isUnnamedBitfield( const ObjectDecl * obj );
+}

src/AST/ParseNode.hpp

r2ed94a9	rb110bcc
40	40	template<typename node_t>
41	41	friend node_t * mutate(const node_t * node);
	42	template<typename node_t>
	43	friend node_t * shallowCopy(const node_t * node);
42	44	};
43	45

src/AST/Pass.impl.hpp

-              r2ed94a9
+              rb110bcc
 #include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
+#include "Common/Iterate.hpp"
 #define VISIT_START( node ) \
 …
         if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
-                maybe_accept( node, &TupleType::members );
+        }

src/AST/Pass.proto.hpp

-              r2ed94a9
+              rb110bcc
 #include "Common/Stats/Heap.h"
 namespace ast {
+template<typename core_t>
+class Pass;
+class TranslationUnit;
+struct PureVisitor;
+template<typename node_t>
+node_t * deepCopy( const node_t * localRoot );
+namespace __pass {
+        typedef std::function<void( void * )> cleanup_func_t;
+        typedef std::function<void( cleanup_func_t, void * )> at_cleanup_t;
+        // boolean reference that may be null
+        // either refers to a boolean value or is null and returns true
+        class bool_ref {
+        public:
+                bool_ref() = default;
+                ~bool_ref() = default;
+                operator bool() { return m_ref ? *m_ref : true; }
+                bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
+        private:
+                friend class visit_children_guard;
+                bool * set( bool * val ) {
+                        bool * prev = m_ref;
+                        m_ref = val;
+                        return prev;
+                }
+                bool * m_ref = nullptr;
+        template<typename core_t> class Pass;
+        class TranslationUnit;
+        struct PureVisitor;
+        template<typename node_t> node_t * deepCopy( const node_t * );
+}
+namespace ast::__pass {
+typedef std::function<void( void * )> cleanup_func_t;
+typedef std::function<void( cleanup_func_t, void * )> at_cleanup_t;
+// boolean reference that may be null
+// either refers to a boolean value or is null and returns true
+class bool_ref {
+public:
+        bool_ref() = default;
+        ~bool_ref() = default;
+        operator bool() { return m_ref ? *m_ref : true; }
+        bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
+private:
+        friend class visit_children_guard;
+        bool * set( bool * val ) {
+                bool * prev = m_ref;
+                m_ref = val;
+                return prev;
+        }
+        bool * m_ref = nullptr;
+};
+// Implementation of the guard value
+// Created inside the visit scope
+class guard_value {
+public:
+        /// Push onto the cleanup
+        guard_value( at_cleanup_t * at_cleanup ) {
+                if( at_cleanup ) {
+                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                push( std::move( func ), val );
+                        };
+                }
+        }
+        ~guard_value() {
+                while( !cleanups.empty() ) {
+                        auto& cleanup = cleanups.top();
+                        cleanup.func( cleanup.val );
+                        cleanups.pop();
+                }
+        }
+        void push( cleanup_func_t && func, void* val ) {
+                cleanups.emplace( std::move(func), val );
+        }
+private:
+        struct cleanup_t {
+                cleanup_func_t func;
+                void * val;
+                cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
         };
+        // Implementation of the guard value
+        // Created inside the visit scope
+        class guard_value {
+        public:
+                /// Push onto the cleanup
+                guard_value( at_cleanup_t * at_cleanup ) {
+                        if( at_cleanup ) {
+                                *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                        push( std::move( func ), val );
+                                };
+                        }
+                }
+                ~guard_value() {
+                        while( !cleanups.empty() ) {
+                                auto& cleanup = cleanups.top();
+                                cleanup.func( cleanup.val );
+                                cleanups.pop();
+                        }
+                }
+                void push( cleanup_func_t && func, void* val ) {
+                        cleanups.emplace( std::move(func), val );
+                }
+        private:
+                struct cleanup_t {
+                        cleanup_func_t func;
+                        void * val;
+                        cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
+                };
+                std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
+        std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
+};
+// Guard structure implementation for whether or not children should be visited
+class visit_children_guard {
+public:
+        visit_children_guard( bool_ref * ref )
+                : m_val ( true )
+                , m_prev( ref ? ref->set( &m_val ) : nullptr )
+                , m_ref ( ref )
+        {}
+        ~visit_children_guard() {
+                if( m_ref ) {
+                        m_ref->set( m_prev );
+                }
+        }
+        operator bool() { return m_val; }
+private:
+        bool       m_val;
+        bool     * m_prev;
+        bool_ref * m_ref;
+};
+/// "Short hand" to check if this is a valid previsit function
+/// Mostly used to make the static_assert look (and print) prettier
+template<typename core_t, typename node_t>
+struct is_valid_previsit {
+        using ret_t = decltype( std::declval<core_t*>()->previsit( std::declval<const node_t *>() ) );
+        static constexpr bool value = std::is_void< ret_t >::value ||
+                std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
+};
+/// The result is a single node.
+template< typename node_t >
+struct result1 {
+        bool differs = false;
+        const node_t * value = nullptr;
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t *, field_t super_t::* field );
+};
+/// The result is a container of statements.
+template< template<class...> class container_t >
+struct resultNstmt {
+        /// The delta/change on a single node.
+        struct delta {
+                ptr<Stmt> new_val;
+                ssize_t old_idx;
+                bool is_old;
+                delta(const Stmt * s, ssize_t i, bool old) :
+                        new_val(s), old_idx(i), is_old(old) {}
         };
+        // Guard structure implementation for whether or not children should be visited
+        class visit_children_guard {
+        public:
+                visit_children_guard( bool_ref * ref )
+                        : m_val ( true )
+                        , m_prev( ref ? ref->set( &m_val ) : nullptr )
+                        , m_ref ( ref )
+                {}
+                ~visit_children_guard() {
+                        if( m_ref ) {
+                                m_ref->set( m_prev );
+                        }
+                }
+                operator bool() { return m_val; }
+        private:
+                bool       m_val;
+                bool     * m_prev;
+                bool_ref * m_ref;
+        };
+        /// "Short hand" to check if this is a valid previsit function
+        /// Mostly used to make the static_assert look (and print) prettier
+        bool differs = false;
+        container_t< delta > values;
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t *, field_t super_t::* field );
+        template< template<class...> class incontainer_t >
+        void take_all( incontainer_t<ptr<Stmt>> * stmts );
+        template< template<class...> class incontainer_t >
+        void take_all( incontainer_t<ptr<Decl>> * decls );
+};
+/// The result is a container of nodes.
+template< template<class...> class container_t, typename node_t >
+struct resultN {
+        bool differs = false;
+        container_t<ptr<node_t>> values;
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t *, field_t super_t::* field );
+};
+/// Used by previsit implementation
+/// We need to reassign the result to 'node', unless the function
+/// returns void, then we just leave 'node' unchanged
+template<bool is_void>
+struct __assign;
+template<>
+struct __assign<true> {
         template<typename core_t, typename node_t>
+        struct is_valid_previsit {
+                using ret_t = decltype( std::declval<core_t*>()->previsit( std::declval<const node_t *>() ) );
+                static constexpr bool value = std::is_void< ret_t >::value ||
+                        std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
+        };
+        /// The result is a single node.
+        template< typename node_t >
+        struct result1 {
+                bool differs = false;
+                const node_t * value = nullptr;
+                template< typename object_t, typename super_t, typename field_t >
+                void apply( object_t *, field_t super_t::* field );
+        };
+        /// The result is a container of statements.
+        template< template<class...> class container_t >
+        struct resultNstmt {
+                /// The delta/change on a single node.
+                struct delta {
+                        ptr<Stmt> new_val;
+                        ssize_t old_idx;
+                        bool is_old;
+                        delta(const Stmt * s, ssize_t i, bool old) :
+                                new_val(s), old_idx(i), is_old(old) {}
+                };
+                bool differs = false;
+                container_t< delta > values;
+                template< typename object_t, typename super_t, typename field_t >
+                void apply( object_t *, field_t super_t::* field );
+                template< template<class...> class incontainer_t >
+                void take_all( incontainer_t<ptr<Stmt>> * stmts );
+                template< template<class...> class incontainer_t >
+                void take_all( incontainer_t<ptr<Decl>> * decls );
+        };
+        /// The result is a container of nodes.
+        template< template<class...> class container_t, typename node_t >
+        struct resultN {
+                bool differs = false;
+                container_t<ptr<node_t>> values;
+                template< typename object_t, typename super_t, typename field_t >
+                void apply( object_t *, field_t super_t::* field );
+        };
+        /// Used by previsit implementation
+        /// We need to reassign the result to 'node', unless the function
+        /// returns void, then we just leave 'node' unchanged
+        template<bool is_void>
+        struct __assign;
+        template<>
+        struct __assign<true> {
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        core.previsit( node );
+                }
+        };
+        template<>
+        struct __assign<false> {
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        node = core.previsit( node );
+                        assertf(node, "Previsit must not return NULL");
+                }
+        };
+        /// Used by postvisit implementation
+        /// We need to return the result unless the function
+        /// returns void, then we just return the original node
+        template<bool is_void>
+        struct __return;
+        template<>
+        struct __return<true> {
+                template<typename core_t, typename node_t>
+                static inline const node_t * result( core_t & core, const node_t * & node ) {
+                        core.postvisit( node );
+                        return node;
+                }
+        };
+        template<>
+        struct __return<false> {
+                template<typename core_t, typename node_t>
+                static inline auto result( core_t & core, const node_t * & node ) {
+                        return core.postvisit( node );
+                }
+        };
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // Deep magic (a.k.a template meta programming) to make the templated visitor work
+        // Basically the goal is to make 2 previsit
+        // 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
+        //     'pass.previsit( node )' that compiles will be used for that node for that type
+        //     This requires that this option only compile for passes that actually define an appropriate visit.
+        //     SFINAE will make sure the compilation errors in this function don't halt the build.
+        //     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
+        // 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
+        //     This is needed only to eliminate the need for passes to specify any kind of handlers.
+        //     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
+        //     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
+        //     the first implementation takes priority in regards to overloading.
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
+        static inline void result( core_t & core, const node_t * & node ) {
+                core.previsit( node );
+        }
+};
+template<>
+struct __assign<false> {
         template<typename core_t, typename node_t>
+        static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
+                static_assert(
+                        is_valid_previsit<core_t, node_t>::value,
+                        "Previsit may not change the type of the node. It must return its paremeter or void."
+                );
+                __assign<
+                        std::is_void<
+                                decltype( core.previsit( node ) )
+                        >::value
+                >::result( core, node );
+        }
+        static inline void result( core_t & core, const node_t * & node ) {
+                node = core.previsit( node );
+                assertf(node, "Previsit must not return NULL");
+        }
+};
+/// Used by postvisit implementation
+/// We need to return the result unless the function
+/// returns void, then we just return the original node
+template<bool is_void>
+struct __return;
+template<>
+struct __return<true> {
         template<typename core_t, typename node_t>
+        static inline auto previsit( core_t &, const node_t *, long ) {}
+        // PostVisit : never mutates the passed pointer but may return a different node
+        static inline const node_t * result( core_t & core, const node_t * & node ) {
+                core.postvisit( node );
+                return node;
+        }
+};
+template<>
+struct __return<false> {
         template<typename core_t, typename node_t>
+        static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+                decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+        {
+                return __return<
+                        std::is_void<
+                                decltype( core.postvisit( node ) )
+                        >::value
+                >::result( core, node );
+        }
+        template<typename core_t, typename node_t>
+        static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // Deep magic (a.k.a template meta programming) continued
+        // To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit
+        // from in order to get extra functionallity for example
+        // class ErrorChecker : WithShortCircuiting { ... };
+        // Pass<ErrorChecker> checker;
+        // this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting
+        // Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // For several accessories, the feature is enabled by detecting that a specific field is present
+        // Use a macro the encapsulate the logic of detecting a particular field
+        // The type is not strictly enforced but does match the accessory
+        #define FIELD_PTR( name, default_type ) \
+        template< typename core_t > \
+        static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
+        static inline auto result( core_t & core, const node_t * & node ) {
+                return core.postvisit( node );
+        }
+};
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) to make the templated visitor work
+// Basically the goal is to make 2 previsit
+// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
+//     'pass.previsit( node )' that compiles will be used for that node for that type
+//     This requires that this option only compile for passes that actually define an appropriate visit.
+//     SFINAE will make sure the compilation errors in this function don't halt the build.
+//     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
+// 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
+//     This is needed only to eliminate the need for passes to specify any kind of handlers.
+//     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
+//     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
+//     the first implementation takes priority in regards to overloading.
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
+template<typename core_t, typename node_t>
+static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
+        static_assert(
+                is_valid_previsit<core_t, node_t>::value,
+                "Previsit may not change the type of the node. It must return its paremeter or void."
+        );
+        __assign<
+                std::is_void<
+                        decltype( core.previsit( node ) )
+                >::value
+        >::result( core, node );
+}
+template<typename core_t, typename node_t>
+static inline auto previsit( core_t &, const node_t *, long ) {}
+// PostVisit : never mutates the passed pointer but may return a different node
+template<typename core_t, typename node_t>
+static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+        decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+{
+        return __return<
+                std::is_void<
+                        decltype( core.postvisit( node ) )
+                >::value
+        >::result( core, node );
+}
+template<typename core_t, typename node_t>
+static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) continued
+// To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit
+// from in order to get extra functionallity for example
+// class ErrorChecker : WithShortCircuiting { ... };
+// Pass<ErrorChecker> checker;
+// this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting
+// Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// For several accessories, the feature is enabled by detecting that a specific field is present
+// Use a macro the encapsulate the logic of detecting a particular field
+// The type is not strictly enforced but does match the accessory
+#define FIELD_PTR( name, default_type ) \
+template< typename core_t > \
+static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
+\
+template< typename core_t > \
+static inline default_type * name( core_t &, long ) { return nullptr; }
+// List of fields and their expected types
+FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
+FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
+FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
+FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > )
+FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > )
+FIELD_PTR( visit_children, __pass::bool_ref )
+FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
+FIELD_PTR( visitor, ast::Pass<core_t> * const )
+// Remove the macro to make sure we don't clash
+#undef FIELD_PTR
+template< typename core_t >
+static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+        // Stats::Heap::stacktrace_push(core_t::traceId);
+}
+template< typename core_t >
+static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+        // Stats::Heap::stacktrace_pop();
+}
+template< typename core_t >
+static void beginTrace(core_t &, long) {}
+template< typename core_t >
+static void endTrace(core_t &, long) {}
+// Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+// If on_error() returns false, the error will be ignored. By default, it returns true.
+template< typename core_t >
+static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
+template< typename core_t >
+static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
+        return core.on_error(decl);
+}
+template< typename core_t, typename node_t >
+static auto make_location_guard( core_t & core, node_t * node, int )
+                -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+        ValueGuardPtr<const CodeLocation *> guard( &core.location );
+        core.location = &node->location;
+        return guard;
+}
+template< typename core_t, typename node_t >
+static auto make_location_guard( core_t &, node_t *, long ) -> int {
+        return 0;
+}
+// Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
+// All passes which have such functions are assumed desire this behaviour
+// detect it using the same strategy
+namespace scope {
+        template<typename core_t>
+        static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                core.beginScope();
+        }
+        template<typename core_t>
+        static inline void enter( core_t &, long ) {}
+        template<typename core_t>
+        static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                core.endScope();
+        }
+        template<typename core_t>
+        static inline void leave( core_t &, long ) {}
+} // namespace scope
+// Certain passes desire an up to date symbol table automatically
+// detect the presence of a member name `symtab` and call all the members appropriately
+namespace symtab {
+        // Some simple scoping rules
+        template<typename core_t>
+        static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                core.symtab.enterScope();
+        }
+        template<typename core_t>
+        static inline auto enter( core_t &, long ) {}
+        template<typename core_t>
+        static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                core.symtab.leaveScope();
+        }
+        template<typename core_t>
+        static inline auto leave( core_t &, long ) {}
+        // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
+        // Create macro to condense these common patterns
+        #define SYMTAB_FUNC1( func, type ) \
+        template<typename core_t> \
+        static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                core.symtab.func( arg ); \
+        } \
+        \
+        template< typename core_t > \
+        static inline default_type * name( core_t &, long ) { return nullptr; }
+        // List of fields and their expected types
+        FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
+        FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
+        FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
+        FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > )
+        FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > )
+        FIELD_PTR( visit_children, __pass::bool_ref )
+        FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
+        FIELD_PTR( visitor, ast::Pass<core_t> * const )
+        // Remove the macro to make sure we don't clash
+        #undef FIELD_PTR
+        template< typename core_t >
+        static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_push(core_t::traceId);
+        }
+        template< typename core_t >
+        static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_pop();
+        }
+        template< typename core_t >
+        static void beginTrace(core_t &, long) {}
+        template< typename core_t >
+        static void endTrace(core_t &, long) {}
+        // Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+        // If onError() returns false, the error will be ignored. By default, it returns true.
+        template< typename core_t >
+        static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
+        template< typename core_t >
+        static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
+                return core.on_error(decl);
+        }
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t & core, node_t * node, int )
+                        -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+                ValueGuardPtr<const CodeLocation *> guard( &core.location );
+                core.location = &node->location;
+                return guard;
+        }
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t &, node_t *, long ) -> int {
+                return 0;
+        }
+        // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
+        // All passes which have such functions are assumed desire this behaviour
+        // detect it using the same strategy
+        namespace scope {
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                        core.beginScope();
+                }
+                template<typename core_t>
+                static inline void enter( core_t &, long ) {}
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                        core.endScope();
+                }
+                template<typename core_t>
+                static inline void leave( core_t &, long ) {}
+        } // namespace scope
+        // Certain passes desire an up to date symbol table automatically
+        // detect the presence of a member name `symtab` and call all the members appropriately
+        namespace symtab {
+                // Some simple scoping rules
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.enterScope();
+                }
+                template<typename core_t>
+                static inline auto enter( core_t &, long ) {}
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.leaveScope();
+                }
+                template<typename core_t>
+                static inline auto leave( core_t &, long ) {}
+                // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
+                // Create macro to condense these common patterns
+                #define SYMTAB_FUNC1( func, type ) \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                        core.symtab.func( arg ); \
+                } \
+                \
+                template<typename core_t> \
+                static inline void func( core_t &, long, type ) {}
+                #define SYMTAB_FUNC2( func, type1, type2 ) \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                        core.symtab.func( arg1, arg2 ); \
+                } \
+                        \
+                template<typename core_t> \
+                static inline void func( core_t &, long, type1, type2 ) {}
+                SYMTAB_FUNC1( addId     , const DeclWithType *  );
+                SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+                SYMTAB_FUNC1( addStruct , const StructDecl *    );
+                SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+                SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+                SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
+                // A few extra functions have more complicated behaviour, they are hand written
+                template<typename core_t>
+                static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
+                        ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
+                        for ( const auto & param : decl->params ) {
+                                fwd->params.push_back( deepCopy( param.get() ) );
+                        }
+                        core.symtab.addStruct( fwd );
+                }
+                template<typename core_t>
+                static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+                template<typename core_t>
+                static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
+                        ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
+                        for ( const auto & param : decl->params ) {
+                                fwd->params.push_back( deepCopy( param.get() ) );
+                        }
+                        core.symtab.addUnion( fwd );
+                }
+                template<typename core_t>
+                static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+                template<typename core_t>
+                static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                        if ( ! core.symtab.lookupStruct( str ) ) {
+                                core.symtab.addStruct( str );
+                        }
+                }
+                template<typename core_t>
+                static inline void addStruct( core_t &, long, const std::string & ) {}
+                template<typename core_t>
+                static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                        if ( ! core.symtab.lookupUnion( str ) ) {
+                                core.symtab.addUnion( str );
+                        }
+                }
+                template<typename core_t>
+                static inline void addUnion( core_t &, long, const std::string & ) {}
+                #undef SYMTAB_FUNC1
+                #undef SYMTAB_FUNC2
+        } // namespace symtab
+        // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+        // Detect the presence of a member name `subs` and call all members appropriately
+        namespace forall {
+                // Some simple scoping rules
+                template<typename core_t>
+                static inline auto enter( core_t & core, int, const ast::FunctionType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) core.subs.beginScope();
+                }
+                template<typename core_t>
+                static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
+                template<typename core_t>
+                static inline auto leave( core_t & core, int, const ast::FunctionType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) { core.subs.endScope(); }
+                }
+                template<typename core_t>
+                static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+                // Replaces a TypeInstType's base TypeDecl according to the table
+                template<typename core_t>
+                static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                -> decltype( core.subs, void() ) {
+                        inst = ast::mutate_field(
+                                inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+                }
+                template<typename core_t>
+                static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+        } // namespace forall
+        // For passes that need access to the global context. Sreaches `translationUnit`
+        namespace translation_unit {
+                template<typename core_t>
+                static inline auto get_cptr( core_t & core, int )
+                                -> decltype( &core.translationUnit ) {
+                        return &core.translationUnit;
+                }
+                template<typename core_t>
+                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                        return nullptr;
+                }
+        }
+        // For passes, usually utility passes, that have a result.
+        namespace result {
+                template<typename core_t>
+                static inline auto get( core_t & core, char ) -> decltype( core.result() ) {
+                        return core.result();
+                }
+                template<typename core_t>
+                static inline auto get( core_t & core, int ) -> decltype( core.result ) {
+                        return core.result;
+                }
+                template<typename core_t>
+                static inline void get( core_t &, long ) {}
+        }
+} // namespace __pass
+} // namespace ast
+        template<typename core_t> \
+        static inline void func( core_t &, long, type ) {}
+        #define SYMTAB_FUNC2( func, type1, type2 ) \
+        template<typename core_t> \
+        static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                core.symtab.func( arg1, arg2 ); \
+        } \
+        \
+        template<typename core_t> \
+        static inline void func( core_t &, long, type1, type2 ) {}
+        SYMTAB_FUNC1( addId     , const DeclWithType *  );
+        SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+        SYMTAB_FUNC1( addStruct , const StructDecl *    );
+        SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+        SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+        SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+        SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
+        // A few extra functions have more complicated behaviour, they are hand written
+        template<typename core_t>
+        static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
+                ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addStruct( fwd );
+        }
+        template<typename core_t>
+        static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+        template<typename core_t>
+        static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
+                ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addUnion( fwd );
+        }
+        template<typename core_t>
+        static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+        template<typename core_t>
+        static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                if ( ! core.symtab.lookupStruct( str ) ) {
+                        core.symtab.addStruct( str );
+                }
+        }
+        template<typename core_t>
+        static inline void addStruct( core_t &, long, const std::string & ) {}
+        template<typename core_t>
+        static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                if ( ! core.symtab.lookupUnion( str ) ) {
+                        core.symtab.addUnion( str );
+                }
+        }
+        template<typename core_t>
+        static inline void addUnion( core_t &, long, const std::string & ) {}
+        #undef SYMTAB_FUNC1
+        #undef SYMTAB_FUNC2
+} // namespace symtab
+// Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+// Detect the presence of a member name `subs` and call all members appropriately
+namespace forall {
+        // Some simple scoping rules
+        template<typename core_t>
+        static inline auto enter( core_t & core, int, const ast::FunctionType * type )
+                        -> decltype( core.subs, void() ) {
+                if ( ! type->forall.empty() ) core.subs.beginScope();
+        }
+        template<typename core_t>
+        static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
+        template<typename core_t>
+        static inline auto leave( core_t & core, int, const ast::FunctionType * type )
+                        -> decltype( core.subs, void() ) {
+                if ( ! type->forall.empty() ) { core.subs.endScope(); }
+        }
+        template<typename core_t>
+        static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+        // Replaces a TypeInstType's base TypeDecl according to the table
+        template<typename core_t>
+        static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                        -> decltype( core.subs, void() ) {
+                inst = ast::mutate_field(
+                        inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+        }
+        template<typename core_t>
+        static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+} // namespace forall
+// For passes that need access to the global context. Searches `translationUnit`
+namespace translation_unit {
+        template<typename core_t>
+        static inline auto get_cptr( core_t & core, int )
+                        -> decltype( &core.translationUnit ) {
+                return &core.translationUnit;
+        }
+        template<typename core_t>
+        static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                return nullptr;
+        }
+}
+// For passes, usually utility passes, that have a result.
+namespace result {
+        template<typename core_t>
+        static inline auto get( core_t & core, char ) -> decltype( core.result() ) {
+                return core.result();
+        }
+        template<typename core_t>
+        static inline auto get( core_t & core, int ) -> decltype( core.result ) {
+                return core.result;
+        }
+        template<typename core_t>
+        static inline void get( core_t &, long ) {}
+}
+} // namespace ast::__pass

src/AST/Print.cpp

-              r2ed94a9
+              rb110bcc
 namespace ast {
+template <typename C, typename... T>
+constexpr array<C,sizeof...(T)> make_array(T&&... values)
+{
+        return array<C,sizeof...(T)>{
+                std::forward<T>(values)...
+        };
+namespace {
+template<typename C, typename... T>
+constexpr array<C, sizeof...(T)> make_array( T&&... values ) {
+        return array<C, sizeof...(T)>{ std::forward<T>( values )... };
+}
+namespace Names {
+        static constexpr auto FuncSpecifiers = make_array<const char*>(
+                "inline", "_Noreturn", "fortran"
+        );
+        static constexpr auto StorageClasses = make_array<const char*>(
+                "extern", "static", "auto", "register", "__thread", "_Thread_local"
+        );
+        static constexpr auto Qualifiers = make_array<const char*>(
+                "const", "restrict", "volatile", "mutex", "_Atomic"
+        );
+}
+template<typename bits_t, size_t N>
+void print( ostream & os, const bits_t & bits,
+                const array<const char *, N> & names ) {
+        if ( !bits.any() ) return;
+        for ( size_t i = 0 ; i < N ; i += 1 ) {
+                if ( bits[i] ) {
+                        os << names[i] << ' ';
+                }
+        }
+}
 …
         static const char* Names[];
-        struct Names {
-                static constexpr auto FuncSpecifiers = make_array<const char*>(
-                        "inline", "_Noreturn", "fortran"
-                );
-                static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
-                );
-                static constexpr auto Qualifiers = make_array<const char*>(
-                        "const", "restrict", "volatile", "mutex", "_Atomic"
-                );
-        };
-        template<typename storage_t, size_t N>
-        void print(const storage_t & storage, const array<const char *, N> & Names ) {
-                if ( storage.any() ) {
-                        for ( size_t i = 0; i < Names.size(); i += 1 ) {
-                                if ( storage[i] ) {
-                                        os << Names[i] << ' ';
+                                }
+                        }
+                }
+        }
-        void print( const ast::Function::Specs & specs ) {
-                print(specs, Names::FuncSpecifiers);
+        }
-        void print( const ast::Storage::Classes & storage ) {
-                print(storage, Names::StorageClasses);
+        }
-        void print( const ast::CV::Qualifiers & qualifiers ) {
-                print(qualifiers, Names::Qualifiers);
+        }
         void print( const std::vector<ast::Label> & labels ) {
                 if ( labels.empty() ) return;
 …
+                }
                 print( node->storage );
+                ast::print( os, node->storage );
                 os << node->typeString();
 …
         void preprint( const ast::Type * node ) {
                 print( node->qualifiers );
+                ast::print( os, node->qualifiers );
+        }
 …
                 print( node->forall );
                 print( node->assertions );
                 print( node->qualifiers );
+                ast::print( os, node->qualifiers );
+        }
         void preprint( const ast::BaseInstType * node ) {
                 print( node->attributes );
                 print( node->qualifiers );
+                ast::print( os, node->qualifiers );
+        }
 …
+                }
                 print( node->storage );
+                ast::print( os, node->storage );
                 if ( node->type ) {
 …
                 if ( ! short_mode ) printAll( node->attributes );
+                print( node->storage );
+                print( node->funcSpec );
+                ast::print( os, node->storage );
+                ast::print( os, node->funcSpec );
                 if ( node->type && node->isTypeFixed ) {
 …
                                 --indent;
+                        }
+                }
+                if ( ! node->withExprs.empty() ) {
+                        // Not with a clause, but the 'with clause'.
+                        ++indent;
+                        os << " with clause" << endl << indent;
+                        printAll( node->withExprs );
+                        --indent;
+                }
 …
         virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
                 os << "Suspend Statement";
                 switch (node->type) {
                         case ast::SuspendStmt::None     : os << " with implicit target"; break;
                         case ast::SuspendStmt::Generator: os << " for generator"; break;
                         case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                switch (node->kind) {
+                case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                case ast::SuspendStmt::Generator: os << " for generator"; break;
+                case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                }
                 os << endl;
 …
 };
+} // namespace
 void print( ostream & os, const ast::Node * node, Indenter indent ) {
         Printer printer { os, indent, false };
 …
+}
+// Annoyingly these needed to be defined out of line to avoid undefined references.
+// The size here needs to be explicit but at least the compiler will produce an error
+// if the wrong size is specified
+constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
+constexpr array<const char*, 6> Printer::Names::StorageClasses;
+constexpr array<const char*, 5> Printer::Names::Qualifiers;
+void print( ostream & os, Function::Specs specs ) {
+        print( os, specs, Names::FuncSpecifiers );
+}
+void print( ostream & os, Storage::Classes storage ) {
+        print( os, storage, Names::StorageClasses );
+}
+void print( ostream & os, CV::Qualifiers qualifiers ) {
+        print( os, qualifiers, Names::Qualifiers );
+}
+} // namespace ast

src/AST/Print.hpp

-              r2ed94a9
+              rb110bcc
 #pragma once
+#include <iostream>
+#include <utility>   // for forward
+#include <iosfwd>
 #include "AST/Node.hpp"
+#include "AST/Fwd.hpp"
 #include "Common/Indenter.h"
 namespace ast {
-class Decl;
 /// Print a node with the given indenter
 …
+}
+/// Print each cv-qualifier used in the set, followed by a space.
+void print( std::ostream & os, CV::Qualifiers );
+/// Print each function specifier used in the set, followed by a space.
+void print( std::ostream & os, Function::Specs );
+/// Print each storage class used in the set, followed by a space.
+void print( std::ostream & os, Storage::Classes );
+}

src/AST/Stmt.hpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Apr 20 14:34:00 2022
 // Update Count     : 36
+// Last Modified On : Wed Apr  5 10:34:00 2023
+// Update Count     : 37
 //
 …
 };
+// A while loop or a do-while loop:
+enum WhileDoKind { While, DoWhile };
 // While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileDoStmt final : public Stmt {
 …
         ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
         bool isDoWhile;
+        WhileDoKind isDoWhile;
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
                                  const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
                                  const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 …
   public:
         ptr<CompoundStmt> then;
         enum Type { None, Coroutine, Generator } type = None;
         SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), then(then), type(type) {}
+        enum Kind { None, Coroutine, Generator } kind = None;
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 };
+// Clause in a waitfor statement: waitfor (..., ...) ...
 class WaitForClause final : public StmtClause {
   public:
 …
         MUTATE_FRIEND
 };
 } // namespace ast

src/AST/SymbolTable.cpp

-              r2ed94a9
+              rb110bcc
         if ( baseExpr ) {
                 if (baseExpr->env) {
                         Expr * base = shallowCopy(baseExpr);
+                        Expr * base = deepCopy(baseExpr);
                         const TypeSubstitution * subs = baseExpr->env;
                         base->env = nullptr;
 …
 void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) {
         // default handling of conflicts is to raise an error
         addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        addIdCommon( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+}
 void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
         // default handling of conflicts is to raise an error
         addId( decl, OnConflict::error(), nullptr, deleter );
+        addIdCommon( decl, OnConflict::error(), nullptr, deleter );
+}
 …
+}
 void SymbolTable::addId(
                 const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
                 const Decl * deleter ) {
+void SymbolTable::addIdCommon(
+                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
         if (kind == NUMBER_OF_KINDS) { // not a special decl
                 addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+                addIdToTable(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+        }
         else {
 …
                         assertf(false, "special decl with non-function type");
+                }
+                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+void SymbolTable::addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
+                const Decl * deleter ) {
+                addIdToTable(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+void SymbolTable::addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
 …
 void SymbolTable::addMembers(
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
         for ( const Decl * decl : aggr->members ) {
                 if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) {
                         addId( dwt, handleConflicts, expr );
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
                                 if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
                                         ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
                                         ast::ptr<ast::TypeSubstitution> tmp = expr->env;
                                         expr = mutate_field(expr, &Expr::env, nullptr);
                                         const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
                                         base = mutate_field(base, &Expr::env, tmp);
                                         addMembers(
+                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+                                }
+                        }
+        for ( const ptr<Decl> & decl : aggr->members ) {
+                auto dwt = decl.as<DeclWithType>();
+                if ( nullptr == dwt ) continue;
+                addIdCommon( dwt, handleConflicts, expr );
+                // Inline through unnamed struct/union members.
+                if ( "" != dwt->name ) continue;
+                const Type * t = dwt->get_type()->stripReferences();
+                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                        expr = mutate_field(expr, &Expr::env, nullptr);
+                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                        base = mutate_field(base, &Expr::env, tmp);
+                        addMembers(
+                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+                }
+        }

src/AST/SymbolTable.hpp

-              r2ed94a9
+              rb110bcc
         /// common code for addId, addDeletedId, etc.
         void addId(
                 const DeclWithType * decl, OnConflict handleConflicts, const Expr * baseExpr = nullptr,
                 const Decl * deleter = nullptr );
+        void addIdCommon(
+                const DeclWithType * decl, OnConflict handleConflicts,
+                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr );
         /// common code for addId when special decls are placed into separate tables
+        void addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts,
+        void addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & idTable, OnConflict handleConflicts,
                 const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/AST/TranslationUnit.hpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Tue Jun 11 15:30:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Mar 11 11:19:00 2022
 // Update Count     : 1
+// Last Modified On : Thr Mar  9 16:41:00 2023
+// Update Count     : 2
 //
 …
 #include <map>
 #include <vector>
+#include <list>
 #include "Fwd.hpp"
 …
         ptr<Type> sizeType;
         const FunctionDecl * dereference;
         const StructDecl * dtorStruct;
         const FunctionDecl * dtorDestroy;
+        const FunctionDecl * dereference = nullptr;
+        const StructDecl * dtorStruct = nullptr;
+        const FunctionDecl * dtorDestroy = nullptr;
 };

src/AST/Type.cpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon May 13 15:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Nov 24  9:49:00 2022
 // Update Count     : 6
+// Last Modified On : Thu Apr  6 15:59:00 2023
+// Update Count     : 7
 //
 …
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
+: Type( q ), types( std::move(ts) ), members() {
+        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
+        // named, but members without initializer nodes end up getting constructors, which breaks
+        // things. This happens because the object decls have to be visited so that their types are
+        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
+        // be eliminated and replaced with a list-view over members. The temporary solution is to
+        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
+        // constructed. Potential better solutions include:
+        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
+        //      similar to the aggregate types.
+        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
+        //      by `genInit`, rather than the current boolean flag.
+        members.reserve( types.size() );
+        for ( const Type * ty : types ) {
+                members.emplace_back( new ObjectDecl{
+                        CodeLocation(), "", ty, new ListInit( CodeLocation(), {}, {}, NoConstruct ),
+                        Storage::Classes{}, Linkage::Cforall } );
+        }
+}
+: Type( q ), types( std::move(ts) ) {}
 bool isUnboundType(const Type * type) {

src/AST/Type.hpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Nov 24  9:47:00 2022
 // Update Count     : 8
+// Last Modified On : Thu Apr  6 15:58:00 2023
+// Update Count     : 9
 //
 …
 };
-/// Function variable arguments flag
-enum ArgumentFlag { FixedArgs, VariableArgs };
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
 …
 public:
         std::vector<ptr<Type>> types;
-        std::vector<ptr<Decl>> members;
         TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} );

src/AST/porting.md

-              r2ed94a9
+              rb110bcc
 * `get_statement()` exclusively used for code location, replaced with `CodeLocation` field
 `CaseStmt`
+`CaseStmt` => `CaseClause`
 * `_isDefault` has been removed
   * `isDefault` calculates value from `cond`
 …
 * `block` -> `body` and `finallyBlock` -> `finally`
 `ThrowStmt` `CatchStmt`
+`ThrowStmt` and `CatchStmt` => `CatchClause`
 * moved `Kind` enums to shared `ast::ExceptionKind` enum
 `FinallyStmt`
+`FinallyStmt` => `FinallyClause`
 * `block` -> `body`
 …
 * Template class, with specializations and using to implement some other types:
   * `StructInstType`, `UnionInstType` & `EnumInstType`
+  * `baseStruct`, `baseUnion` & `baseEnum` => `base`
 `TypeInstType`

src/CodeGen/CodeGenerator.cc

-              r2ed94a9
+              rb110bcc
 #include <cassert>                   // for assert, assertf
 #include <list>                      // for _List_iterator, list, list<>::it...
+#include <sstream>                   // for stringstream
 #include "AST/Decl.hpp"              // for DeclWithType
 #include "Common/UniqueName.h"       // for UniqueName
-#include "Common/utility.h"          // for CodeLocation, toString
 #include "GenType.h"                 // for genType
 #include "InitTweak/InitTweak.h"     // for getPointerBase

src/Common/CodeLocationTools.cpp

-              r2ed94a9
+              rb110bcc
 struct LeafKindVisitor : public ast::Visitor {
         LeafKind kind;
+        LeafKind result;
 #define VISIT(node_type, return_type) \
         const ast::return_type * visit( const ast::node_type * ) final { \
                 kind = LeafKind::node_type; \
+                result = LeafKind::node_type; \
                 return nullptr; \
+        }
 …
 LeafKind get_leaf_kind( ast::Node const * node ) {
+        LeafKindVisitor visitor;
+        node->accept( visitor );
+        return visitor.kind;
+        return ast::Pass<LeafKindVisitor>::read( node );
+}

src/Common/DeclStats.cpp

r2ed94a9	rb110bcc
23	23	#include <iostream>
24	24	#include <map>
	25	#include <sstream>
25	26	#include <unordered_map>
26	27	#include <unordered_set>

src/Common/Eval.cc

-              r2ed94a9
+              rb110bcc
 // file "LICENCE" distributed with Cforall.
 //
 // utility.h --
+// Eval.cc -- Evaluate parts of the ast at compile time.
 //
 // Author           : Richard C. Bilson
 …
 // Update Count     : 119
 //
+#include "Eval.h"
 #include <utility> // for pair

src/Common/ResolvProtoDump.cpp

-              r2ed94a9
+              rb110bcc
 #include <iostream>
 #include <set>
+#include <sstream>
 #include <unordered_set>
 …
 #include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
-#include "Common/utility.h"
 namespace {

src/Common/SemanticError.h

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  2 10:59:10 2023
 // Update Count     : 36
+// Last Modified On : Sat Feb 25 12:01:31 2023
+// Update Count     : 37
 //
 …
         {"self-assign"              , Severity::Warn    , "self assignment of expression: %s"                          },
         {"reference-conversion"     , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
         {"qualifiers-zero_t-one_t"  , Severity::Warn    , "questionable use of type qualifier %s with %s"              },
+        {"qualifiers-zero_t-one_t"  , Severity::Warn    , "questionable use of type qualifier(s) with %s"              },
         {"aggregate-forward-decl"   , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
         {"superfluous-decl"         , Severity::Warn    , "declaration does not allocate storage: %s"                  },

src/Common/module.mk

-              r2ed94a9
+              rb110bcc
         Common/CodeLocationTools.hpp \
         Common/CodeLocationTools.cpp \
-        Common/CompilerError.h \
-        Common/Debug.h \
         Common/DeclStats.hpp \
         Common/DeclStats.cpp \
         Common/ErrorObjects.h \
         Common/Eval.cc \
+        Common/Eval.h \
         Common/Examine.cc \
         Common/Examine.h \
 …
         Common/Indenter.h \
         Common/Indenter.cc \
+        Common/Iterate.hpp \
         Common/PassVisitor.cc \
         Common/PassVisitor.h \
 …
         Common/Stats/Time.cc \
         Common/Stats/Time.h \
         Common/UnimplementedError.h \
+        Common/ToString.hpp \
         Common/UniqueName.cc \
         Common/UniqueName.h \

src/Common/utility.h

-              r2ed94a9
+              rb110bcc
 // file "LICENCE" distributed with Cforall.
 //
 // utility.h --
+// utility.h -- General utilities used across the compiler.
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Apr 25 14:26:00 2022
 // Update Count     : 51
+// Last Modified On : Fri Feb 17 15:25:00 2023
+// Update Count     : 53
 //
 …
 #include <cctype>
 #include <algorithm>
-#include <functional>
 #include <iostream>
-#include <iterator>
 #include <list>
 #include <memory>
-#include <sstream>
 #include <string>
 #include <type_traits>
-#include <utility>
 #include <vector>
 #include <cstring>                                                                              // memcmp
 …
                 return 0;
         } // if
+}
-template< typename T, typename U >
-struct maybeBuild_t {
-        static T * doit( const U *orig ) {
-                if ( orig ) {
-                        return orig->build();
-                } else {
-                        return 0;
-                } // if
+        }
-};
-template< typename T, typename U >
-static inline T * maybeBuild( const U *orig ) {
-        return maybeBuild_t<T,U>::doit(orig);
+}
-template< typename T, typename U >
-static inline T * maybeMoveBuild( const U *orig ) {
-        T* ret = maybeBuild<T>(orig);
-        delete orig;
-        return ret;
+}
 …
         splice( src, dst );
         dst.swap( src );
+}
-template < typename T >
-void toString_single( std::ostream & os, const T & value ) {
-        os << value;
+}
-template < typename T, typename... Params >
-void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
-        os << value;
-        toString_single( os, params ... );
+}
-template < typename ... Params >
-std::string toString( const Params & ... params ) {
-        std::ostringstream os;
-        toString_single( os, params... );
-        return os.str();
+}
-#define toCString( ... ) toString( __VA_ARGS__ ).c_str()
-// replace element of list with all elements of another list
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
-        typename std::list< T >::iterator next = pos; advance( next, 1 );
-        //if ( next != org.end() ) {
-        org.erase( pos );
-        org.splice( next, with );
-        //}
-        return;
+}
-// replace range of a list with a single element
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
-        org.insert( begin, with );
-        org.erase( begin, end );
+}
 …
+}
-template< typename... Args >
-auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {
-  return zipWith(std::forward<Args>(args)..., std::make_pair);
+}
-template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
-void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
-        while ( b1 != e1 && b2 != e2 )
-                *out++ = func(*b1++, *b2++);
+}
-// it's nice to actually be able to increment iterators by an arbitrary amount
-template< class InputIt, class Distance >
-InputIt operator+( InputIt it, Distance n ) {
-        advance(it, n);
-        return it;
+}
-template< typename T >
-void warn_single( const T & arg ) {
-        std::cerr << arg << std::endl;
+}
-template< typename T, typename... Params >
-void warn_single(const T & arg, const Params & ... params ) {
-        std::cerr << arg;
-        warn_single( params... );
+}
-template< typename... Params >
-void warn( const Params & ... params ) {
-        std::cerr << "Warning: ";
-        warn_single( params... );
+}
 // determines if pref is a prefix of str
 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
         if ( pref.size() > str.size() ) return false;
+    return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
+        // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
+}
+// -----------------------------------------------------------------------------
+// Ref Counted Singleton class
+// Objects that inherit from this class will have at most one reference to it
+// but if all references die, the object will be deleted.
+template< typename ThisType >
+class RefCountSingleton {
+  public:
+        static std::shared_ptr<ThisType> get() {
+                if( global_instance.expired() ) {
+                        std::shared_ptr<ThisType> new_instance = std::make_shared<ThisType>();
+                        global_instance = new_instance;
+                        return std::move(new_instance);
+                }
+                return global_instance.lock();
+        }
+  private:
+        static std::weak_ptr<ThisType> global_instance;
+};
+template< typename ThisType >
+std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
+        return pref == str.substr(start, pref.size());
+}
 // -----------------------------------------------------------------------------
 …
         ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } }
 };
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : reverseIterate( container ) ) {}
-// syntax to have a for each that iterates backwards
-template< typename T >
-struct reverse_iterate_t {
-        T& ref;
-        reverse_iterate_t( T & ref ) : ref(ref) {}
-        // this does NOT work on const T!!!
-        // typedef typename T::reverse_iterator iterator;
-        auto begin() { return ref.rbegin(); }
-        auto end() { return ref.rend(); }
-};
-template< typename T >
-reverse_iterate_t< T > reverseIterate( T & ref ) {
-        return reverse_iterate_t< T >( ref );
+}
-template< typename T >
-struct enumerate_t {
-        template<typename val_t>
-        struct value_t {
-                val_t & val;
-                size_t idx;
-        };
-        template< typename iter_t, typename val_t >
-        struct iterator_t {
-                iter_t it;
-                size_t idx;
-                iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {}
-                value_t<val_t> operator*() const { return value_t<val_t>{ *it, idx }; }
-                bool operator==(const iterator_t & o) const { return o.it == it; }
-                bool operator!=(const iterator_t & o) const { return o.it != it; }
-                iterator_t & operator++() {
-                        it++;
-                        idx++;
-                        return *this;
+                }
-                using difference_type   = typename std::iterator_traits< iter_t >::difference_type;
-                using value_type        = value_t<val_t>;
-                using pointer           = value_t<val_t> *;
-                using reference         = value_t<val_t> &;
-                using iterator_category = std::forward_iterator_tag;
-        };
-        T & ref;
-        using iterator = iterator_t< typename T::iterator, typename T::value_type >;
-        using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >;
-        iterator begin() { return iterator( ref.begin(), 0 ); }
-        iterator end()   { return iterator( ref.end(), ref.size() ); }
-        const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator end()   const { return const_iterator( ref.cend(), ref.size() ); }
-        const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator cend()   const { return const_iterator( ref.cend(), ref.size() ); }
-};
-template< typename T >
-enumerate_t<T> enumerate( T & ref ) {
-        return enumerate_t< T >{ ref };
+}
-template< typename T >
-const enumerate_t< const T > enumerate( const T & ref ) {
-        return enumerate_t< const T >{ ref };
+}
-template< typename OutType, typename Range, typename Functor >
-OutType map_range( const Range& range, Functor&& functor ) {
-        OutType out;
-        std::transform(
-                begin( range ),
-                end( range ),
-                std::back_inserter( out ),
-                std::forward< Functor >( functor )
-        );
-        return out;
+}
-// -----------------------------------------------------------------------------
-// Helper struct and function to support:
-// for ( auto val : group_iterate( container1, container2, ... ) ) { ... }
-// This iteraters through multiple containers of the same size.
-template<typename... Args>
-class group_iterate_t {
-        using Iterables = std::tuple<Args...>;
-        Iterables iterables;
-        // Getting the iterator and value types this way preserves const.
-        template<size_t I> using Iter = decltype(std::get<I>(iterables).begin());
-        template<size_t I> using Data = decltype(*std::get<I>(iterables).begin());
-        template<typename> struct base_iterator;
-        // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1`
-        // into a pack. These are the indexes into the tuples, so unpacking can
-        // go over each element of the tuple.
-        // The std::integer_sequence is just used to build that sequence.
-        // A library reference will probably explain it better than I can.
-        template<std::size_t... Indices>
-        struct base_iterator<std::integer_sequence<std::size_t, Indices...>> {
-                using value_type = std::tuple< Data<Indices>... >;
-                std::tuple<Iter<Indices>...> iterators;
-                base_iterator( Iter<Indices>... is ) : iterators( is... ) {}
-                base_iterator operator++() {
-                        return base_iterator( ++std::get<Indices>( iterators )... );
+                }
-                bool operator!=( const base_iterator& other ) const {
-                        return iterators != other.iterators;
+                }
-                value_type operator*() const {
-                        return std::tie( *std::get<Indices>( iterators )... );
+                }
-                static base_iterator make_begin( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).begin()... );
+                }
-                static base_iterator make_end( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).end()... );
+                }
-        };
-public:
-        group_iterate_t( const Args &... args ) : iterables( args... ) {}
-        using iterator = base_iterator<decltype(
-                std::make_integer_sequence<std::size_t, sizeof...(Args)>())>;
-        iterator begin() { return iterator::make_begin( iterables ); }
-        iterator end() { return iterator::make_end( iterables ); }
-};
-// Helpers for the bounds checks (the non-varatic part of group_iterate):
-static inline void runGroupBoundsCheck(size_t size0, size_t size1) {
-        assertf( size0 == size1,
-                "group iteration requires containers of the same size: <%zd, %zd>.",
-                size0, size1 );
+}
-static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) {
-        assertf( size0 == size1 && size1 == size2,
-                "group iteration requires containers of the same size: <%zd, %zd, %zd>.",
-                size0, size1, size2 );
+}
-/// Performs bounds check to ensure that all arguments are of the same length.
-template< typename... Args >
-group_iterate_t<Args...> group_iterate( Args &&... args ) {
-        runGroupBoundsCheck( args.size()... );
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
-/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
-template< typename... Args >
-group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : lazy_map( container1, f ) ) {}
-// syntax to have a for each that iterates a container, mapping each element by applying f
-template< typename T, typename Func >
-struct lambda_iterate_t {
-        const T & ref;
-        std::function<Func> f;
-        struct iterator {
-                typedef decltype(begin(ref)) Iter;
-                Iter it;
-                std::function<Func> f;
-                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
-                iterator & operator++() {
-                        ++it; return *this;
+                }
-                bool operator!=( const iterator &other ) const { return it != other.it; }
-                auto operator*() const -> decltype(f(*it)) { return f(*it); }
-        };
-        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
-        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
-        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
-};
-template< typename... Args >
-lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
-        return lambda_iterate_t<Args...>( args...);
+}
 // -----------------------------------------------------------------------------
 …
 } // ilog2
-// -----------------------------------------------------------------------------
-/// evaluates expr as a long long int. If second is false, expr could not be evaluated
-std::pair<long long int, bool> eval(const Expression * expr);
-namespace ast {
-        class Expr;
+}
-std::pair<long long int, bool> eval(const ast::Expr * expr);
-// -----------------------------------------------------------------------------
-/// Reorders the input range in-place so that the minimal-value elements according to the
-/// comparator are in front;
-/// returns the iterator after the last minimal-value element.
-template<typename Iter, typename Compare>
-Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
-        if ( begin == end ) return end;
-        Iter min_pos = begin;
-        for ( Iter i = begin + 1; i != end; ++i ) {
-                if ( lt( *i, *min_pos ) ) {
-                        // new minimum cost; swap into first position
-                        min_pos = begin;
-                        std::iter_swap( min_pos, i );
-                } else if ( ! lt( *min_pos, *i ) ) {
-                        // duplicate minimum cost; swap into next minimum position
-                        ++min_pos;
-                        std::iter_swap( min_pos, i );
+                }
+        }
-        return ++min_pos;
+}
-template<typename Iter, typename Compare>
-inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
-        return sort_mins( begin, end, lt );
+}
-/// sort_mins defaulted to use std::less
-template<typename Iter>
-inline Iter sort_mins( Iter begin, Iter end ) {
-        return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
+}
 // Local Variables: //
 // tab-width: 4 //

src/CompilationState.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
 // Last Modified By : Henry Xue
 // Last Modified On : Tue Jul 20 04:27:35 2021
 // Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 19:12:50 2023
+// Update Count     : 6
 //
 …
         expraltp = false,
         genericsp = false,
+        invariant = false,
         libcfap = false,
         nopreludep = false,

src/CompilationState.h

-              r2ed94a9
+              rb110bcc
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
 // Last Modified By : Henry Xue
 // Last Modified On : Tue Jul 20 04:27:35 2021
 // Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 19:12:53 2023
+// Update Count     : 6
 //
 …
         expraltp,
         genericsp,
+        invariant,
         libcfap,
         nopreludep,

src/Concurrency/Actors.cpp

-              r2ed94a9
+              rb110bcc
     // finds and sets a ptr to the actor, message, and request structs, which are needed in the next pass
     void previsit( const StructDecl * decl ) {
+        GuardValue(insideStruct);
+        insideStruct = true;
+        parentDecl = mutate( decl );
+        if( decl->name == "actor" ) *actorDecl = decl;
+        if( decl->name == "message" ) *msgDecl = decl;
+        if( decl->name == "request" ) *requestDecl = decl;
+        if ( !decl->body ) return;
+        if ( decl->name == "actor" ) {
+            actorStructDecls.insert( decl ); // skip inserting fwd decl
+            *actorDecl = decl;
+        } else if( decl->name == "message" ) {
+            messageStructDecls.insert( decl ); // skip inserting fwd decl
+            *msgDecl = decl;
+        } else if( decl->name == "request" ) *requestDecl = decl;
+        else {
+            GuardValue(insideStruct);
+            insideStruct = true;
+            parentDecl = mutate( decl );
+        }
+        }
 …
+    }
     // this collects the valid actor and message struct decl pts
+    // this collects the derived actor and message struct decl ptrs
     void postvisit( const StructInstType * node ) {
         if ( ! *actorDecl || ! *msgDecl ) return;
         if ( insideStruct && !namedDecl ) {
+            if ( node->aggr() == *actorDecl ) {
+            auto actorIter = actorStructDecls.find( node->aggr() );
+            if ( actorIter != actorStructDecls.end() ) {
                 actorStructDecls.insert( parentDecl );
+            } else if ( node->aggr() == *msgDecl ) {
+                return;
+            }
+            auto messageIter = messageStructDecls.find( node->aggr() );
+            if ( messageIter != messageStructDecls.end() ) {
                 messageStructDecls.insert( parentDecl );
+            }
 …
 };
+#define __ALLOC 0 // C_TODO: complete swap to no-alloc version
+struct GenReceiveDecls : public ast::WithDeclsToAdd<> {
+// generates the definitions of send operators for actors
+// collects data needed for next pass that does the circular defn resolution
+//     for message send operators (via table above)
+struct GenFuncsCreateTables : public ast::WithDeclsToAdd<> {
     unordered_set<const StructDecl *> & actorStructDecls;
     unordered_set<const StructDecl *>  & messageStructDecls;
 …
     FwdDeclTable & forwardDecls;
+    // generates the operator for actor message sends
         void postvisit( const FunctionDecl * decl ) {
         // return if not of the form receive( param1, param2 ) or if it is a forward decl
 …
         auto messageIter = messageStructDecls.find( arg2InstType->aggr() );
         if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
-            // check that we have found all the decls we need from <actor.hfa>
-            if ( !*allocationDecl || !*requestDecl )
-                SemanticError( decl->location, "using actors requires a header, add #include <actor.hfa>\n" );
             //////////////////////////////////////////////////////////////////////
             // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
             /*
                 static inline derived_actor & ?|?( derived_actor & receiver, derived_msg & msg ) {
                     request * new_req = alloc();
+                    request new_req;
                     Allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
                     __receive_fn fn = (__receive_fn)my_work_fn;
                     (*new_req){ &receiver, &msg, fn };
                     send( receiver, *new_req );
+                    new_req{ &receiver, &msg, fn };
+                    send( receiver, new_req );
                     return receiver;
+                }
             */ // C_TODO: update this with new no alloc version
+            */
             CompoundStmt * sendBody = new CompoundStmt( decl->location );
-            #if __ALLOC
-            // Generates: request * new_req = alloc();
-            sendBody->push_back( new DeclStmt(
-                decl->location,
-                new ObjectDecl(
-                    decl->location,
-                    "new_req",
-                    new PointerType( new StructInstType( *requestDecl ) ),
-                    new SingleInit( decl->location, new UntypedExpr( decl->location, new NameExpr( decl->location, "alloc" ), {} ) )
+                )
-            ));
-            #else
             // Generates: request new_req;
             sendBody->push_back( new DeclStmt(
 …
+                )
             ));
-            #endif
             // Function type is: Allocation (*)( derived_actor &, derived_msg & )
 …
             ));
             // Function type is: Allocation (*)( actor &, messsage & )
+            // Function type is: Allocation (*)( actor &, message & )
             FunctionType * genericReceive = new FunctionType();
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
 …
             genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
             // Generates: Allocation (*fn)( actor &, messsage & ) = (Allocation (*)( actor &, messsage & ))my_work_fn;
+            // Generates: Allocation (*fn)( actor &, message & ) = (Allocation (*)( actor &, message & ))my_work_fn;
             // More readable synonymous code:
             //     typedef Allocation (*__receive_fn)(actor &, message &);
 …
             ));
-            #if __ALLOC
-            // Generates: (*new_req){ &receiver, &msg, fn };
-            sendBody->push_back( new ExprStmt(
-                decl->location,
-                                new UntypedExpr (
-                    decl->location,
-                                        new NameExpr( decl->location, "?{}" ),
+                                        {
-                                                new UntypedExpr( decl->location, new NameExpr( decl->location, "*?" ), {  new NameExpr( decl->location, "new_req" ) } ),
-                        new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
-                        new AddressExpr( new NameExpr( decl->location, "msg" ) ),
-                        new NameExpr( decl->location, "fn" )
+                                        }
+                                )
-                        ));
-            // Generates: send( receiver, *new_req );
-            sendBody->push_back( new ExprStmt(
-                decl->location,
-                                new UntypedExpr (
-                    decl->location,
-                                        new NameExpr( decl->location, "send" ),
+                                        {
+                                                {
-                            new NameExpr( decl->location, "receiver" ),
-                            new UntypedExpr( decl->location, new NameExpr( decl->location, "*?" ), {  new NameExpr( decl->location, "new_req" ) } )
+                        }
+                                        }
+                                )
-                        ));
-            #else
             // Generates: new_req{ &receiver, &msg, fn };
             sendBody->push_back( new ExprStmt(
 …
+                                )
                         ));
-            #endif
             // Generates: return receiver;
 …
             FunctionDecl * sendOperatorFunction = new FunctionDecl(
                 decl->location,
                 "?|?",
+                "?<<?",
                 {},                     // forall
+                {
 …
             // forward decls to resolve use before decl problem for '|' routines
             forwardDecls.insertDecl( *actorIter, *messageIter , ast::deepCopy( sendOperatorFunction ) );
-            // forwardDecls.push_back( ast::deepCopy( sendOperatorFunction ) );
             sendOperatorFunction->stmts = sendBody;
 …
   public:
     GenReceiveDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
+    GenFuncsCreateTables( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
         const StructDecl ** requestDecl, const EnumDecl ** allocationDecl, const StructDecl ** actorDecl, const StructDecl ** msgDecl,
         FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls),
 …
 };
+struct GenFwdDecls : public ast::WithDeclsToAdd<> {
+// separate pass is needed since this pass resolves circular defn issues
+// generates the forward declarations of the send operator for actor routines
+struct FwdDeclOperator : public ast::WithDeclsToAdd<> {
     unordered_set<const StructDecl *> & actorStructDecls;
     unordered_set<const StructDecl *>  & messageStructDecls;
     FwdDeclTable & forwardDecls;
+    // handles forward declaring the message operator
     void postvisit( const StructDecl * decl ) {
         list<FunctionDecl *> toAddAfter;
 …
   public:
+    GenFwdDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
+        FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls),
+        forwardDecls(forwardDecls) {}
+    FwdDeclOperator( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
+        FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls), forwardDecls(forwardDecls) {}
 };
 …
     Pass<CollectactorStructDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl,
         allocationDecl, actorDecl, msgDecl );
+    // check that we have found all the decls we need from <actor.hfa>, if not no need to run the rest of this pass
+    if ( !allocationDeclPtr || !requestDeclPtr || !actorDeclPtr || !msgDeclPtr )
+        return;
     // second pass locates all receive() routines that overload the generic receive fn
     // it then generates the appropriate operator '|' send routines for the receive routines
     Pass<GenReceiveDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl,
+    Pass<GenFuncsCreateTables>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl,
         allocationDecl, actorDecl, msgDecl, forwardDecls );
     // The third pass forward declares operator '|' send routines
     Pass<GenFwdDecls>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
+    Pass<FwdDeclOperator>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
+}

src/Concurrency/Actors.hpp

r2ed94a9	rb110bcc
5	5	// file "LICENCE" distributed with Cforall.
6	6	//
7		// ~~Keywords.h~~ -- Implement concurrency constructs from their keywords.
	7	// Actors.hpp -- Implement concurrency constructs from their keywords.
8	8	//
9	9	// Author : Colby Parsons

src/Concurrency/KeywordsNew.cpp

r2ed94a9	rb110bcc
779	779
780	780	const ast::Stmt * SuspendKeyword::postvisit( const ast::SuspendStmt * stmt ) {
781		switch ( stmt->~~type~~ ) {
	781	switch ( stmt->kind ) {
782	782	case ast::SuspendStmt::None:
783	783	// Use the context to determain the implicit target.

src/ControlStruct/ExceptDeclNew.cpp

r2ed94a9	rb110bcc
15	15
16	16	#include "ExceptDecl.h"
	17
	18	#include <sstream>
17	19
18	20	#include "AST/Decl.hpp"

src/ControlStruct/ExceptTranslateNew.cpp

-              r2ed94a9
+              rb110bcc
                 nullptr,
                 ast::Storage::Classes{},
+                ast::Linkage::Cforall
+                ast::Linkage::Cforall,
+                {},
+                { ast::Function::Inline }
         );
+}

src/ControlStruct/MLEMutator.cc

r2ed94a9	rb110bcc
25	25	#include <memory> // for allocator_traits<>::value_...
26	26
27		#include "Common/~~utility.h" // for toString, operator+~~
	27	#include "Common/ToString.hpp" // for toString
28	28	#include "ControlStruct/LabelGenerator.h" // for LabelGenerator
29	29	#include "MLEMutator.h"

src/GenPoly/Box.cc

-              r2ed94a9
+              rb110bcc
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for toString
+#include "Common/ToString.hpp"           // for toCString
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
 …
                         CallAdapter();
+                        void premutate( Declaration * declaration );
                         void premutate( FunctionDecl * functionDecl );
                         void premutate( TypeDecl * typeDecl );
 …
                 CallAdapter::CallAdapter() : tempNamer( "_temp" ) {}
+                void CallAdapter::premutate( Declaration * ) {
+                        // Prevent type declaration information from leaking out.
+                        GuardScope( scopeTyVars );
+                }
                 void CallAdapter::premutate( FunctionDecl *functionDecl ) {

src/GenPoly/FindFunction.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri Feb 05 12:22:20 2016
 // Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 17:05:20 2022
+// Update Count     : 7
 //
 …
 #include <utility>                      // for pair
+#include "AST/Pass.hpp"                 // for Pass
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 …
                 handleForall( pointerType->get_forall() );
+        }
+namespace {
+struct FindFunctionCore :
+                public ast::WithGuards,
+                public ast::WithShortCircuiting,
+                public ast::WithVisitorRef<FindFunctionCore> {
+        FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate,
+                bool replaceMode );
+        void previsit( ast::FunctionType const * type );
+        ast::Type const * postvisit( ast::FunctionType const * type );
+        void previsit( ast::PointerType const * type );
+private:
+        void handleForall( const ast::FunctionType::ForallList & forall );
+        std::vector<ast::ptr<ast::FunctionType>> &functions;
+        TypeVarMap typeVars;
+        FindFunctionPred predicate;
+        bool replaceMode;
+};
+FindFunctionCore::FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap &typeVars, FindFunctionPred predicate,
+                bool replaceMode ) :
+        functions( functions ), typeVars( typeVars ),
+        predicate( predicate ), replaceMode( replaceMode ) {}
+void FindFunctionCore::handleForall( const ast::FunctionType::ForallList & forall ) {
+        for ( const ast::ptr<ast::TypeInstType> & td : forall ) {
+                TypeVarMap::iterator var = typeVars.find( *td );
+                if ( var != typeVars.end() ) {
+                        typeVars.erase( var->first );
+                } // if
+        } // for
+}
+void FindFunctionCore::previsit( ast::FunctionType const * type ) {
+        visit_children = false;
+        GuardScope( typeVars );
+        handleForall( type->forall );
+        //ast::accept_all( type->returns, *visitor );
+        // This might have to become ast::mutate_each with return.
+        ast::accept_each( type->returns, *visitor );
+}
+ast::Type const * FindFunctionCore::postvisit( ast::FunctionType const * type ) {
+        ast::Type const * ret = type;
+        if ( predicate( type, typeVars ) ) {
+                functions.push_back( type );
+                if ( replaceMode ) {
+                        // replace type parameters in function type with void*
+                        ret = scrubTypeVars( ast::deepCopy( type ), typeVars );
+                } // if
+        } // if
+        return ret;
+}
+void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
+        GuardScope( typeVars );
+        //handleForall( type->forall );
+}
+} // namespace
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
+        type->accept( pass );
+        //(void)type;
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+}
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
+        return type->accept( pass );
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+        //return type;
+}
 } // namespace GenPoly

src/GenPoly/FindFunction.h

-              r2ed94a9
+              rb110bcc
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:36 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 10:30:00 2022
+// Update Count     : 3
 //
 …
         /// like `findFunction`, but also replaces the function type with void ()(void)
         void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+typedef bool (*FindFunctionPred)( const ast::FunctionType *, const TypeVarMap & );
+/// Recursively walks `type`, placing all functions that match `predicate`
+/// under `typeVars` into `functions`.
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
+/// Like findFunction, but also replaces the function type with `void ()(void)`.
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

-              r2ed94a9
+              rb110bcc
+        }
+const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) {
+        if ( func->returns.empty() ) return nullptr;
+        TypeVarMap forallTypes = { ast::TypeData() };
+        makeTypeVarMap( func, forallTypes );
+        return isDynType( func->returns.front(), forallTypes );
+}
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
 //              if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
 …
                 return 0;
+        }
+const ast::Type * isPolyPtr(
+                const ast::Type * type, const TypeVarMap & typeVars,
+                const ast::TypeSubstitution * typeSubs ) {
+        type = replaceTypeInst( type, typeSubs );
+        if ( auto * ptr = dynamic_cast<ast::PointerType const *>( type ) ) {
+                return isPolyType( ptr->base, typeVars, typeSubs );
+        }
+        return nullptr;
+}
         Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
 …
+        }
+void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) {
+        typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) );
+}
 void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
         typeVars.insert( *type, ast::TypeData( type->base ) );
+        typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) );
+}
 …
+}
+void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars ) {
+        for ( auto & typeDecl : decl->type_params ) {
+                addToTypeVarMap( typeDecl, typeVars );
+        }
+}
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/GenPoly.h

-              r2ed94a9
+              rb110bcc
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
         void addToTypeVarMap( const ast::TypeDecl * type, TypeVarMap & typeVars );
+        void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars );
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
         void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars );
+        void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars );
         /// Prints type variable map

src/GenPoly/Lvalue.cc

r2ed94a9	rb110bcc
17	17	#include <string> // for string
18	18
	19	#include "Common/ToString.hpp" // for toCString
19	20	#include "Common/UniqueName.h"
20	21	#include "Common/PassVisitor.h"

src/GenPoly/LvalueNew.cpp

r2ed94a9	rb110bcc
25	25	#include "AST/Pass.hpp"
26	26	#include "Common/SemanticError.h" // for SemanticWarning
	27	#include "Common/ToString.hpp" // for toCString
27	28	#include "Common/UniqueName.h" // for UniqueName
28	29	#include "GenPoly/GenPoly.h" // for genFunctionType

src/InitTweak/FixInit.cc

-              r2ed94a9
+              rb110bcc
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
-#include "Common/utility.h"            // for CodeLocation, ValueGuard, toSt...
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
 …
+                }
-                template< typename Visitor, typename... Params >
-                void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                        SemanticErrorException err( loc, toString( params... ) );
-                        v.errors.append( err );
+                }
                 template< typename... Params >
                 void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
+                        // toggle warnings vs. errors here.
+                        // warn( params... );
+                        error( *this, loc, params... );
+                        SemanticErrorException err( loc, toString( params... ) );
+                        errors.append( err );
+                }

src/InitTweak/FixInitNew.cpp

-              r2ed94a9
+              rb110bcc
 #include <utility>                     // for pair
+#include "AST/DeclReplacer.hpp"
+#include "AST/Expr.hpp"
 #include "AST/Inspect.hpp"             // for getFunction, getPointerBase, g...
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Print.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/GenType.h"           // for genPrettyType
 #include "CodeGen/OperatorTable.h"
-#include "Common/CodeLocationTools.hpp"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
-#include "Common/utility.h"            // for CodeLocation, ValueGuard, toSt...
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
 …
 #include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "SymTab/Autogen.h"            // for genImplicitCall
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
 …
 #include "Validate/FindSpecialDecls.h" // for dtorStmt, dtorStructDestroy
-#include "AST/Expr.hpp"
-#include "AST/Node.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Print.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
-#include "AST/DeclReplacer.hpp"
 extern bool ctordtorp; // print all debug
 extern bool ctorp; // print ctor debug
 …
 namespace InitTweak {
 namespace {
+        // Shallow copy the pointer list for return.
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams( const ast::Type * t ) {
+                if ( auto inst = dynamic_cast<const ast::StructInstType *>( t ) ) {
+                        return inst->base->params;
+                }
+                if ( auto inst = dynamic_cast<const ast::UnionInstType *>( t ) ) {
+                        return inst->base->params;
+                }
+                return {};
+        }
+        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
+        ast::FunctionDecl * genDefaultFunc(
+                        const CodeLocation loc,
+                        const std::string fname,
+                        const ast::Type * paramType,
+                        bool maybePolymorphic = true) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if ( maybePolymorphic ) typeParams = getGenericParams( paramType );
+                auto dstParam = new ast::ObjectDecl( loc,
+                        "_dst",
+                        new ast::ReferenceType( paramType ),
+                        nullptr,
+                        {},
+                        ast::Linkage::Cforall
+                );
+                return new ast::FunctionDecl( loc,
+                        fname,
+                        std::move(typeParams),
+                        {dstParam},
+                        {},
+                        new ast::CompoundStmt(loc),
+                        {},
+                        ast::Linkage::Cforall
+                );
+        }
         struct SelfAssignChecker {
                 void previsit( const ast::ApplicationExpr * appExpr );
 …
         private:
                 /// hack to implement WithTypeSubstitution while conforming to mutation safety.
                 ast::TypeSubstitution * env;
                 bool                    envModified;
+                ast::TypeSubstitution * env         = nullptr;
+                bool                    envModified = false;
         };
 …
                 void previsit( const ast::FunctionDecl * ) { visit_children = false; }
           protected:
+        protected:
                 ObjectSet curVars;
         };
 …
                 SemanticErrorException errors;
           private:
+        private:
                 template< typename... Params >
                 void emit( CodeLocation, const Params &... params );
 …
                 static UniqueName dtorNamer( "__cleanup_dtor" );
                 std::string name = dtorNamer.newName();
                 ast::FunctionDecl * dtorFunc = SymTab::genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
+                ast::FunctionDecl * dtorFunc = genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
                 stmtsToAdd.push_back( new ast::DeclStmt(loc, dtorFunc ) );
 …
+        {
                 static UniqueName tempNamer("_tmp_cp");
-                assert( env );
                 const CodeLocation loc = impCpCtorExpr->location;
                 // CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
 …
                 // xxx - this originally mutates arg->result in place. is it correct?
+                assert( env );
                 result = env->applyFree( result.get() ).node;
                 auto mutResult = result.get_and_mutate();
 …
         void InsertDtors::previsit( const ast::BranchStmt * stmt ) {
                 switch( stmt->kind ) {
                   case ast::BranchStmt::Continue:
                   case ast::BranchStmt::Break:
+                case ast::BranchStmt::Continue:
+                case ast::BranchStmt::Break:
                         // could optimize the break/continue case, because the S_L-S_G check is unnecessary (this set should
                         // always be empty), but it serves as a small sanity check.
                   case ast::BranchStmt::Goto:
+                case ast::BranchStmt::Goto:
                         handleGoto( stmt );
                         break;
                   default:
+                default:
                         assert( false );
                 } // switch
 …
+        }
-        template< typename Visitor, typename... Params >
-        void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                SemanticErrorException err( loc, toString( params... ) );
-                v.errors.append( err );
+        }
         template< typename... Params >
         void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
+                // toggle warnings vs. errors here.
+                // warn( params... );
+                error( *this, loc, params... );
+                SemanticErrorException err( loc, toString( params... ) );
+                errors.append( err );
+        }
 …
                 // xxx - functions returning ast::ptr seems wrong...
                 auto res = ResolvExpr::findVoidExpression( untypedExpr, { symtab, transUnit().global } );
+                // Fix CodeLocation (at least until resolver is fixed).
+                auto fix = localFillCodeLocations( untypedExpr->location, res.release() );
+                return strict_dynamic_cast<const ast::Expr *>( fix );
+                return res.release();
+        }

src/InitTweak/GenInit.cc

-              r2ed94a9
+              rb110bcc
 #include "Common/PassVisitor.h"        // for PassVisitor, WithGuards, WithShort...
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for ValueGuard, maybeClone
 …
 #include "ResolvExpr/Resolver.h"
 #include "SymTab/Autogen.h"            // for genImplicitCall
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"            // for Mangler
 #include "SynTree/LinkageSpec.h"       // for isOverridable, C

src/Parser/DeclarationNode.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  8 17:07:00 2022
 // Update Count     : 1185
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Apr 20 11:46:00 2023
+// Update Count     : 1393
 //
+#include "DeclarationNode.h"
 #include <cassert>                 // for assert, assertf, strict_dynamic_cast
 …
 #include <string>                  // for string, operator+, allocator, char...
+#include "AST/Attribute.hpp"       // for Attribute
+#include "AST/Copy.hpp"            // for shallowCopy
+#include "AST/Decl.hpp"            // for Decl
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Print.hpp"           // for print
+#include "AST/Stmt.hpp"            // for AsmStmt, DirectiveStmt
+#include "AST/StorageClasses.hpp"  // for Storage::Class
+#include "AST/Type.hpp"            // for Type
+#include "Common/CodeLocation.h"   // for CodeLocation
+#include "Common/Iterate.hpp"      // for reverseIterate
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild, CodeLocation
+#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
+#include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
+#include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineMemberDecl, Declaration
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr
+#include "SynTree/Statement.h"     // for AsmStmt
+#include "SynTree/Type.h"          // for Type, Type::StorageClasses, Type::...
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/ExpressionNode.h" // for ExpressionNode
+#include "Parser/InitializerNode.h"// for InitializerNode
+#include "Parser/StatementNode.h"  // for StatementNode
 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
 #include "TypedefTable.h"          // for TypedefTable
 …
 // These must harmonize with the corresponding DeclarationNode enumerations.
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "int128",
+                                                                                                   "float", "double", "long double", "float80", "float128",
+                                                                                                   "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames" };
+const char * DeclarationNode::complexTypeNames[] = { "_Complex", "NoComplexTypeNames", "_Imaginary" }; // Imaginary unsupported => parse, but make invisible and print error message
+const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
+const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
+const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" };
+const char * DeclarationNode::basicTypeNames[] = {
+        "void", "_Bool", "char", "int", "int128",
+        "float", "double", "long double", "float80", "float128",
+        "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames"
+};
+const char * DeclarationNode::complexTypeNames[] = {
+        "_Complex", "NoComplexTypeNames", "_Imaginary"
+}; // Imaginary unsupported => parse, but make invisible and print error message
+const char * DeclarationNode::signednessNames[] = {
+        "signed", "unsigned", "NoSignednessNames"
+};
+const char * DeclarationNode::lengthNames[] = {
+        "short", "long", "long long", "NoLengthNames"
+};
+const char * DeclarationNode::builtinTypeNames[] = {
+        "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames"
+};
 UniqueName DeclarationNode::anonymous( "__anonymous" );
 extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
+extern ast::Linkage::Spec linkage;                                              // defined in parser.yy
 DeclarationNode::DeclarationNode() :
 …
 //      variable.name = nullptr;
         variable.tyClass = TypeDecl::NUMBER_OF_KINDS;
+        variable.tyClass = ast::TypeDecl::NUMBER_OF_KINDS;
         variable.assertions = nullptr;
         variable.initializer = nullptr;
-//      attr.name = nullptr;
-        attr.expr = nullptr;
-        attr.type = nullptr;
         assert.condition = nullptr;
         assert.message = nullptr;
 …
 DeclarationNode::~DeclarationNode() {
-//      delete attr.name;
-        delete attr.expr;
-        delete attr.type;
 //      delete variable.name;
         delete variable.assertions;
         delete variable.initializer;
 //      delete type;
+//      delete type;
         delete bitfieldWidth;
 …
         newnode->hasEllipsis = hasEllipsis;
         newnode->linkage = linkage;
         newnode->asmName = maybeClone( asmName );
         cloneAll( attributes, newnode->attributes );
+        newnode->asmName = maybeCopy( asmName );
+        newnode->attributes = attributes;
         newnode->initializer = maybeClone( initializer );
         newnode->extension = extension;
 …
         newnode->variable.initializer = maybeClone( variable.initializer );
-//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
-        newnode->attr.expr = maybeClone( attr.expr );
-        newnode->attr.type = maybeClone( attr.type );
         newnode->assert.condition = maybeClone( assert.condition );
         newnode->assert.message = maybeClone( assert.message );
+        newnode->assert.message = maybeCopy( assert.message );
         return newnode;
 } // DeclarationNode::clone
 …
         } // if
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
         } // if
         storageClasses.print( os );
         funcSpecs.print( os );
+        if ( linkage != ast::Linkage::Cforall ) {
+                os << ast::Linkage::name( linkage ) << " ";
+        } // if
+        ast::print( os, storageClasses );
+        ast::print( os, funcSpecs );
         if ( type ) {
 …
         } // if
+        for ( Attribute * attr: reverseIterate( attributes ) ) {
+                os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str();
+        } // for
+        if ( ! attributes.empty() ) {
+                os << string( indent + 2, ' ' ) << "with attributes " << endl;
+                for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( attributes ) ) {
+                        os << string( indent + 4, ' ' ) << attr->name.c_str() << endl;
+                } // for
+        } // if
         os << endl;
 …
+}
 DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
+DeclarationNode * DeclarationNode::newStorageClass( ast::Storage::Classes sc ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->storageClasses = sc;
 …
 } // DeclarationNode::newStorageClass
 DeclarationNode * DeclarationNode::newFuncSpecifier( Type::FuncSpecifiers fs ) {
+DeclarationNode * DeclarationNode::newFuncSpecifier( ast::Function::Specs fs ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->funcSpecs = fs;
 …
 } // DeclarationNode::newFuncSpecifier
 DeclarationNode * DeclarationNode::newTypeQualifier( Type::Qualifiers tq ) {
+DeclarationNode * DeclarationNode::newTypeQualifier( ast::CV::Qualifiers tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
 …
+}
 DeclarationNode * DeclarationNode::newAggregate( AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+DeclarationNode * DeclarationNode::newAggregate( ast::AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
+        newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->aggregate.anon = name == nullptr;
+        newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
 …
         newnode->type->aggregate.tagged = false;
         newnode->type->aggregate.parent = nullptr;
-        newnode->type->aggregate.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
+        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->enumeration.anon = name == nullptr;
+        newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
-        newnode->type->enumeration.anon = name == nullptr;
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
         if ( base && base->type)  {
+        if ( base && base->type )  {
                 newnode->type->base = base->type;
         } // if
 …
         return newnode;
 } // DeclarationNode::newEnum
 DeclarationNode * DeclarationNode::newName( const string * name ) {
 …
 } // DeclarationNode::newFromTypeGen
 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
+DeclarationNode * DeclarationNode::newTypeParam( ast::TypeDecl::Kind tc, const string * name ) {
         DeclarationNode * newnode = newName( name );
         newnode->type = nullptr;
 …
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.name = name;
         newnode->type->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggregate.kind = ast::AggregateDecl::Trait;
         newnode->type->aggregate.params = params;
         newnode->type->aggregate.fields = asserts;
 …
         newnode->type = new TypeData( TypeData::AggregateInst );
         newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
         newnode->type->aggInst.aggregate->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggInst.aggregate->aggregate.kind = ast::AggregateDecl::Trait;
         newnode->type->aggInst.aggregate->aggregate.name = name;
         newnode->type->aggInst.params = params;
 …
         newnode->type->array.dimension = size;
         newnode->type->array.isStatic = isStatic;
         if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
+        if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ast::ConstantExpr *>() ) {
                 newnode->type->array.isVarLen = false;
         } else {
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = nullptr;
         std::list< Expression * > exprs;
+        std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
+        newnode->attributes.push_back( new Attribute( *name, exprs ) );
+        newnode->attributes.push_back(
+                new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
 …
+}
 DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, Expression * message ) {
+DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, ast::Expr * message ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->assert.condition = condition;
 …
+}
+void appendError( string & dst, const string & src ) {
+static void appendError( string & dst, const string & src ) {
         if ( src.empty() ) return;
         if ( dst.empty() ) { dst = src; return; }
 …
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
+        const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        if ( (qsrc & qdst).any() ) {                                            // duplicates ?
+                for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
+                        if ( qsrc[i] && qdst[i] ) {
+                                appendError( error, string( "duplicate " ) + Type::QualifiersNames[i] );
+                        } // if
+                } // for
+        const ast::CV::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        const ast::CV::Qualifiers duplicates = qsrc & qdst;
+        if ( duplicates.any() ) {
+                std::stringstream str;
+                str << "duplicate ";
+                ast::print( str, duplicates );
+                str << "qualifier(s)";
+                appendError( error, str.str() );
         } // for
 } // DeclarationNode::checkQualifiers
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
+        if ( (funcSpecs & src->funcSpecs).any() ) {                     // duplicates ?
+                for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
+                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
+                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiersNames[i] );
+                        } // if
+                } // for
+        } // if
+        if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
+                if ( (storageClasses & src->storageClasses ).any() ) { // duplicates ?
+                        for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
+                                if ( storageClasses[i] && src->storageClasses[i] ) {
+                                        appendError( error, string( "duplicate " ) + Type::StorageClassesNames[i] );
+                                } // if
+                        } // for
+                        // src is the new item being added and has a single bit
+                } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ?
+                        appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
+                                                 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
+                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
+                } // if
+        ast::Function::Specs fsDups = funcSpecs & src->funcSpecs;
+        if ( fsDups.any() ) {
+                std::stringstream str;
+                str << "duplicate ";
+                ast::print( str, fsDups );
+                str << "function specifier(s)";
+                appendError( error, str.str() );
+        } // if
+        // Skip if everything is unset.
+        if ( storageClasses.any() && src->storageClasses.any() ) {
+                ast::Storage::Classes dups = storageClasses & src->storageClasses;
+                // Check for duplicates.
+                if ( dups.any() ) {
+                        std::stringstream str;
+                        str << "duplicate ";
+                        ast::print( str, dups );
+                        str << "storage class(es)";
+                        appendError( error, str.str() );
+                // Check for conflicts.
+                } else if ( !src->storageClasses.is_threadlocal_any() ) {
+                        std::stringstream str;
+                        str << "conflicting ";
+                        ast::print( str, ast::Storage::Classes( 1 << storageClasses.ffs() ) );
+                        str << "& ";
+                        ast::print( str, ast::Storage::Classes( 1 << src->storageClasses.ffs() ) );
+                        str << "storage classes";
+                        appendError( error, str.str() );
+                        // FIX to preserve invariant of one basic storage specifier
+                        src->storageClasses.reset();
+                }
         } // if
 …
         storageClasses |= q->storageClasses;
+        for ( Attribute * attr: reverseIterate( q->attributes ) ) {
+                attributes.push_front( attr->clone() );
+        } // for
+        std::vector<ast::ptr<ast::Attribute>> tmp;
+        tmp.reserve( q->attributes.size() );
+        for ( auto const & attr : q->attributes ) {
+                tmp.emplace_back( ast::shallowCopy( attr.get() ) );
+        }
+        spliceBegin( attributes, tmp );
         return this;
 } // DeclarationNode::copySpecifiers
 …
         checkQualifiers( type, q->type );
         if ( (builtin == Zero || builtin == One) && q->type->qualifiers.val != 0 && error.length() == 0 ) {
                 SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, Type::QualifiersNames[ilog2( q->type->qualifiers.val )], builtinTypeNames[builtin] );
+        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.any() && error.length() == 0 ) {
+                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, builtinTypeNames[builtin] );
         } // if
         addQualifiersToType( q->type, type );
 …
         } else {
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
+                case TypeData::Unknown:
                         src->qualifiers |= dst->qualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
+                case TypeData::Basic:
                         dst->qualifiers |= src->qualifiers;
                         if ( src->kind != TypeData::Unknown ) {
 …
                         } // if
                         break;
                   default:
+                default:
                         switch ( src->kind ) {
                           case TypeData::Aggregate:
                           case TypeData::Enum:
+                        case TypeData::Aggregate:
+                        case TypeData::Enum:
                                 dst->base = new TypeData( TypeData::AggregateInst );
                                 dst->base->aggInst.aggregate = src;
 …
                                 src = nullptr;
                                 break;
                           default:
+                        default:
                                 if ( dst->forall ) {
                                         dst->forall->appendList( src->forall );
 …
 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
                 if ( variable.assertions ) {
                         variable.assertions->appendList( assertions );
                 } else {
                         variable.assertions = assertions;
                 } // if
                 return this;
+        if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
+                if ( variable.assertions ) {
+                        variable.assertions->appendList( assertions );
+                } else {
+                        variable.assertions = assertions;
+                } // if
+                return this;
         } // if
         assert( type );
         switch ( type->kind ) {
           case TypeData::Symbolic:
+        case TypeData::Symbolic:
                 if ( type->symbolic.assertions ) {
                         type->symbolic.assertions->appendList( assertions );
 …
                 } // if
                 break;
           default:
+        default:
                 assert( false );
         } // switch
 …
 DeclarationNode * DeclarationNode::copyAttribute( DeclarationNode * a ) {
         if ( a ) {
+                for ( Attribute *attr: reverseIterate( a->attributes ) ) {
+                        attributes.push_front( attr );
+                } // for
+                spliceBegin( attributes, a->attributes );
                 a->attributes.clear();
         } // if
 …
                 if ( type ) {
                         switch ( type->kind ) {
                           case TypeData::Aggregate:
                           case TypeData::Enum:
+                        case TypeData::Aggregate:
+                        case TypeData::Enum:
                                 p->type->base = new TypeData( TypeData::AggregateInst );
                                 p->type->base->aggInst.aggregate = type;
 …
                                 break;
                           default:
+                        default:
                                 p->type->base = type;
                         } // switch
 …
 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
   if ( ! a ) return this;
+        if ( ! a ) return this;
         assert( a->type->kind == TypeData::Array );
         TypeData * lastArray = findLast( a->type );
         if ( type ) {
                 switch ( type->kind ) {
                   case TypeData::Aggregate:
                   case TypeData::Enum:
+                case TypeData::Aggregate:
+                case TypeData::Enum:
                         lastArray->base = new TypeData( TypeData::AggregateInst );
                         lastArray->base->aggInst.aggregate = type;
 …
                         lastArray->base->qualifiers |= type->qualifiers;
                         break;
                   default:
+                default:
                         lastArray->base = type;
                 } // switch
 …
 DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
         assertf( variable.tyClass != TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
+        assertf( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
         variable.initializer = init;
         return this;
 …
+}
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList ) {
+// If a typedef wraps an anonymous declaration, name the inner declaration
+// so it has a consistent name across translation units.
+static void nameTypedefedDecl(
+                DeclarationNode * innerDecl,
+                const DeclarationNode * outerDecl ) {
+        TypeData * outer = outerDecl->type;
+        assert( outer );
+        // First make sure this is a typedef:
+        if ( outer->kind != TypeData::Symbolic || !outer->symbolic.isTypedef ) {
+                return;
+        }
+        TypeData * inner = innerDecl->type;
+        assert( inner );
+        // Always clear any CVs associated with the aggregate:
+        inner->qualifiers.reset();
+        // Handle anonymous aggregates: typedef struct { int i; } foo
+        if ( inner->kind == TypeData::Aggregate && inner->aggregate.anon ) {
+                delete inner->aggregate.name;
+                inner->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
+                inner->aggregate.anon = false;
+                assert( outer->base );
+                delete outer->base->aggInst.aggregate->aggregate.name;
+                outer->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
+                outer->base->aggInst.aggregate->aggregate.anon = false;
+                outer->base->aggInst.aggregate->qualifiers.reset();
+        // Handle anonymous enumeration: typedef enum { A, B, C } foo
+        } else if ( inner->kind == TypeData::Enum && inner->enumeration.anon ) {
+                delete inner->enumeration.name;
+                inner->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
+                inner->enumeration.anon = false;
+                assert( outer->base );
+                delete outer->base->aggInst.aggregate->enumeration.name;
+                outer->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
+                outer->base->aggInst.aggregate->enumeration.anon = false;
+                // No qualifiers.reset() here.
+        }
+}
+// This code handles a special issue with the attribute transparent_union.
+//
+//    typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union ))
+//
+// Here the attribute aligned goes with the typedef_name, so variables declared of this type are
+// aligned.  However, the attribute transparent_union must be moved from the typedef_name to
+// alias union U.  Currently, this is the only know attribute that must be moved from typedef to
+// alias.
+static void moveUnionAttribute( ast::Decl * decl, ast::UnionDecl * unionDecl ) {
+        if ( auto typedefDecl = dynamic_cast<ast::TypedefDecl *>( decl ) ) {
+                // Is the typedef alias a union aggregate?
+                if ( nullptr == unionDecl ) return;
+                // If typedef is an alias for a union, then its alias type was hoisted above and remembered.
+                if ( auto unionInstType = typedefDecl->base.as<ast::UnionInstType>() ) {
+                        auto instType = ast::mutate( unionInstType );
+                        // Remove all transparent_union attributes from typedef and move to alias union.
+                        for ( auto attr = instType->attributes.begin() ; attr != instType->attributes.end() ; ) {
+                                assert( *attr );
+                                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
+                                        unionDecl->attributes.emplace_back( attr->release() );
+                                        attr = instType->attributes.erase( attr );
+                                } else {
+                                        attr++;
+                                }
+                        }
+                        typedefDecl->base = instType;
+                }
+        }
+}
+// Get the non-anonymous name of the instance type of the declaration,
+// if one exists.
+static const std::string * getInstTypeOfName( ast::Decl * decl ) {
+        if ( auto dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
+                if ( auto aggr = dynamic_cast<ast::BaseInstType const *>( dwt->get_type() ) ) {
+                        if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                return &aggr->name;
+                        }
+                }
+        }
+        return nullptr;
+}
+void buildList( DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< std::list< Declaration * > > out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
                 try {
+                        bool extracted = false;
+                        bool anon = false;
+                        bool extracted_named = false;
+                        ast::UnionDecl * unionDecl = nullptr;
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
+                                // handle the case where a structure declaration is contained within an object or type declaration
+                                Declaration * decl = extr->build();
+                                if ( decl ) {
+                                        // hoist the structure declaration
+                                        decl->location = cur->location;
+                                        * out++ = decl;
+                                assert( cur->type );
+                                nameTypedefedDecl( extr, cur );
+                                if ( ast::Decl * decl = extr->build() ) {
+                                        // Remember the declaration if it is a union aggregate ?
+                                        unionDecl = dynamic_cast<ast::UnionDecl *>( decl );
+                                        *out++ = decl;
                                         // need to remember the cases where a declaration contains an anonymous aggregate definition
-                                        extracted = true;
                                         assert( extr->type );
                                         if ( extr->type->kind == TypeData::Aggregate ) {
+                                                anon = extr->type->aggregate.anon;
+                                                // typedef struct { int A } B is the only case?
+                                                extracted_named = !extr->type->aggregate.anon;
                                         } else if ( extr->type->kind == TypeData::Enum ) {
+                                                // xxx - is it useful to have an implicit anonymous enum member?
+                                                anon = extr->type->enumeration.anon;
+                                                // typedef enum { A } B is the only case?
+                                                extracted_named = !extr->type->enumeration.anon;
+                                        } else {
+                                                extracted_named = true;
+                                        }
                                 } // if
 …
                         } // if
+                        Declaration * decl = cur->build();
+                        if ( decl ) {
+                                // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
+                                // struct S {
+                                //   struct T { int x; }; // no anonymous member
+                                //   struct { int y; };   // anonymous member
+                                //   struct T;            // anonymous member
+                                // };
+                                if ( ! (extracted && decl->name == "" && ! anon && ! cur->get_inLine()) ) {
+                                        if ( decl->name == "" ) {
+                                                if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>( decl ) ) {
+                                                        if ( ReferenceToType * aggr = dynamic_cast<ReferenceToType *>( dwt->get_type() ) ) {
+                                                                if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                                                        if ( ! cur->get_inLine() ) {
+                                                                                // temporary: warn about anonymous member declarations of named types, since
+                                                                                // this conflicts with the syntax for the forward declaration of an anonymous type
+                                                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, aggr->name.c_str() );
+                                                                        } // if
+                                                                } // if
+                                                        } // if
+                                                } // if
+                                        } // if
+                                        decl->location = cur->location;
+                                        *out++ = decl;
+                        if ( ast::Decl * decl = cur->build() ) {
+                                moveUnionAttribute( decl, unionDecl );
+                                if ( "" == decl->name && !cur->get_inLine() ) {
+                                        // Don't include anonymous declaration for named aggregates,
+                                        // but do include them for anonymous aggregates, e.g.:
+                                        // struct S {
+                                        //   struct T { int x; }; // no anonymous member
+                                        //   struct { int y; };   // anonymous member
+                                        //   struct T;            // anonymous member
+                                        // };
+                                        if ( extracted_named ) {
+                                                continue;
+                                        }
+                                        if ( auto name = getInstTypeOfName( decl ) ) {
+                                                // Temporary: warn about anonymous member declarations of named types, since
+                                                // this conflicts with the syntax for the forward declaration of an anonymous type.
+                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, name->c_str() );
+                                        }
                                 } // if
+                                *out++ = decl;
                         } // if
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
 …
 // currently only builds assertions, function parameters, and return values
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList ) {
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::DeclWithType>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::DeclWithType>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
                 try {
                         Declaration * decl = cur->build();
                         assert( decl );
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        ast::Decl * decl = cur->build();
+                        assertf( decl, "buildList: build for ast::DeclWithType." );
+                        if ( ast::DeclWithType * dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
                                 dwt->location = cur->location;
                                 *out++ = dwt;
                         } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
+                        } else if ( ast::StructDecl * agg = dynamic_cast<ast::StructDecl *>( decl ) ) {
                                 // e.g., int foo(struct S) {}
                                 StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;
+                                auto inst = new ast::StructInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location, "", inst );
+                                obj->linkage = linkage;
                                 *out++ = obj;
                                 delete agg;
                         } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                        } else if ( ast::UnionDecl * agg = dynamic_cast<ast::UnionDecl *>( decl ) ) {
                                 // e.g., int foo(union U) {}
+                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                auto inst = new ast::UnionInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location,
+                                        "", inst, nullptr, ast::Storage::Classes(),
+                                        linkage );
                                 *out++ = obj;
                         } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
+                        } else if ( ast::EnumDecl * agg = dynamic_cast<ast::EnumDecl *>( decl ) ) {
                                 // e.g., int foo(enum E) {}
+                                EnumInstType * inst = new EnumInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                auto inst = new ast::EnumInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location,
+                                        "",
+                                        inst,
+                                        nullptr,
+                                        ast::Storage::Classes(),
+                                        linkage
+                                );
                                 *out++ = obj;
+                        } else {
+                                assertf( false, "buildList: Could not convert to ast::DeclWithType." );
                         } // if
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
 …
 } // buildList
+void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList ) {
+void buildTypeList( const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Type>> & outputList ) {
         SemanticErrorException errors;
+        std::back_insert_iterator< std::list< Type * > > out( outputList );
+        const DeclarationNode * cur = firstNode;
+        while ( cur ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Type>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
                 try {
                         * out++ = cur->buildType();
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
+        } // while
+        } // for
         if ( ! errors.isEmpty() ) {
 …
 } // buildTypeList
 Declaration * DeclarationNode::build() const {
+ast::Decl * DeclarationNode::build() const {
         if ( ! error.empty() ) SemanticError( this, error + " in declaration of " );
         if ( asmStmt ) {
+                return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
+                auto stmt = strict_dynamic_cast<ast::AsmStmt *>( asmStmt->build() );
+                return new ast::AsmDecl( stmt->location, stmt );
         } // if
         if ( directiveStmt ) {
+                return new DirectiveDecl( strict_dynamic_cast<DirectiveStmt *>( directiveStmt->build() ) );
+        } // if
+        if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
+                auto stmt = strict_dynamic_cast<ast::DirectiveStmt *>( directiveStmt->build() );
+                return new ast::DirectiveDecl( stmt->location, stmt );
+        } // if
+        if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
                 // otype is internally converted to dtype + otype parameters
                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dimension };
                 static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
+                static const ast::TypeDecl::Kind kindMap[] = { ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Ftype, ast::TypeDecl::Ttype, ast::TypeDecl::Dimension };
+                static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == ast::TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype || variable.tyClass == TypeDecl::DStype, variable.initializer ? variable.initializer->buildType() : nullptr );
+                buildList( variable.assertions, ret->get_assertions() );
+                ast::TypeDecl * ret = new ast::TypeDecl( location,
+                        *name,
+                        ast::Storage::Classes(),
+                        (ast::Type *)nullptr,
+                        kindMap[ variable.tyClass ],
+                        variable.tyClass == ast::TypeDecl::Otype || variable.tyClass == ast::TypeDecl::DStype,
+                        variable.initializer ? variable.initializer->buildType() : nullptr
+                );
+                buildList( variable.assertions, ret->assertions );
                 return ret;
         } // if
 …
                 } // if
                 bool isDelete = initializer && initializer->get_isDelete();
+                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+                ast::Decl * decl = buildDecl(
+                        type,
+                        name ? *name : string( "" ),
+                        storageClasses,
+                        maybeBuild( bitfieldWidth ),
+                        funcSpecs,
+                        linkage,
+                        asmName,
+                        isDelete ? nullptr : maybeBuild( initializer ),
+                        copy( attributes )
+                )->set_extension( extension );
                 if ( isDelete ) {
                         DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
+                        auto dwt = strict_dynamic_cast<ast::DeclWithType *>( decl );
                         dwt->isDeleted = true;
+                }
 …
         if ( assert.condition ) {
+                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
+                auto cond = maybeBuild( assert.condition );
+                auto msg = strict_dynamic_cast<ast::ConstantExpr *>( maybeCopy( assert.message ) );
+                return new ast::StaticAssertDecl( location, cond, msg );
+        }
 …
         } // if
         if ( enumInLine ) {
+                return new InlineMemberDecl( *name, storageClasses, linkage, nullptr );
+                return new ast::InlineMemberDecl( location,
+                        *name, (ast::Type*)nullptr, storageClasses, linkage );
         } // if
         assertf( name, "ObjectDecl must a have name\n" );
+        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
+}
+Type * DeclarationNode::buildType() const {
+        auto ret = new ast::ObjectDecl( location,
+                *name,
+                (ast::Type*)nullptr,
+                maybeBuild( initializer ),
+                storageClasses,
+                linkage,
+                maybeBuild( bitfieldWidth )
+        );
+        ret->asmName = asmName;
+        ret->extension = extension;
+        return ret;
+}
+ast::Type * DeclarationNode::buildType() const {
         assert( type );
-        if ( attr.expr ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
-        } else if ( attr.type ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
-        } // if
         switch ( type->kind ) {
+          case TypeData::Enum:
+          case TypeData::Aggregate: {
+                  ReferenceToType * ret = buildComAggInst( type, attributes, linkage );
+                  buildList( type->aggregate.actuals, ret->get_parameters() );
+                  return ret;
+          }
+          case TypeData::Symbolic: {
+                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes );
+                  buildList( type->symbolic.actuals, ret->get_parameters() );
+                  return ret;
+          }
+          default:
+                Type * simpletypes = typebuild( type );
+                simpletypes->get_attributes() = attributes;             // copy because member is const
+        case TypeData::Enum:
+        case TypeData::Aggregate: {
+                ast::BaseInstType * ret =
+                        buildComAggInst( type, copy( attributes ), linkage );
+                buildList( type->aggregate.actuals, ret->params );
+                return ret;
+        }
+        case TypeData::Symbolic: {
+                ast::TypeInstType * ret = new ast::TypeInstType(
+                        *type->symbolic.name,
+                        // This is just a default, the true value is not known yet.
+                        ast::TypeDecl::Dtype,
+                        buildQualifiers( type ),
+                        copy( attributes ) );
+                buildList( type->symbolic.actuals, ret->params );
+                return ret;
+        }
+        default:
+                ast::Type * simpletypes = typebuild( type );
+                // copy because member is const
+                simpletypes->attributes = attributes;
                 return simpletypes;
         } // switch

src/Parser/ExpressionNode.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 13:17:07 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Aug  7 09:18:56 2021
+// Update Count     : 1077
+//
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:07:00 2023
+// Update Count     : 1083
+//
+#include "ExpressionNode.h"
 #include <cassert>                 // for assert
 …
 #include <string>                  // for string, operator+, operator==
+#include "AST/Expr.hpp"            // for NameExpr
+#include "AST/Type.hpp"            // for BaseType, SueInstType
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild, CodeLo...
+#include "ParseNode.h"             // for ExpressionNode, maybeMoveBuildType
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for EnumDecl, StructDecl, UnionDecl
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr, NameExpr
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement
+#include "SynTree/Type.h"          // for BasicType, Type, Type::Qualifiers
+#include "DeclarationNode.h"       // for DeclarationNode
+#include "InitializerNode.h"       // for InitializerNode
 #include "parserutility.h"         // for notZeroExpr
-class Initializer;
 using namespace std;
 …
 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
 // type.
-extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
 // static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
 …
         size_t end = str.length() - 1;
         if ( posn == end ) { type = 3; return; }                        // no length after 'l' => long
         string::size_type next = posn + 1;                                      // advance to length
         if ( str[next] == '3' ) {                                                       // 32
 …
                 if ( str[i] == '1' ) v |= 1;
                 i += 1;
           if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
                 v <<= 1;
         } // for
 } // scanbin
+Expression * build_constantInteger( string & str ) {
+        static const BasicType::Kind kind[2][6] = {
+ast::Expr * build_constantInteger(
+                const CodeLocation & location, string & str ) {
+        static const ast::BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh) because shorter type has the longer suffix
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ BasicType::LongLongSignedInt, },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ BasicType::LongLongUnsignedInt, },
+                { ast::BasicType::ShortSignedInt, ast::BasicType::SignedChar, ast::BasicType::SignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ ast::BasicType::LongLongSignedInt, },
+                { ast::BasicType::ShortUnsignedInt, ast::BasicType::UnsignedChar, ast::BasicType::UnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ ast::BasicType::LongLongUnsignedInt, },
         };
 …
         string str2( "0x0" );
         unsigned long long int v, v2 = 0;                                       // converted integral value
         Expression * ret, * ret2;
+        ast::Expr * ret, * ret2;
         int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
 …
         // special constants
         if ( str == "0" ) {
                 ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) );
+                ret = new ast::ConstantExpr( location, new ast::ZeroType(), str, 0 );
                 goto CLEANUP;
         } // if
         if ( str == "1" ) {
                 ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) );
+                ret = new ast::ConstantExpr( location, new ast::OneType(), str, 1 );
                 goto CLEANUP;
         } // if
-        string::size_type posn;
         // 'u' can appear before or after length suffix
 …
         } else {
                 // At least one digit in integer constant, so safe to backup while looking for suffix.
+                posn = str.find_last_of( "pP" );                                // pointer value
+                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "zZ" );                                // size_t
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+                posn = str.rfind( "hh" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.rfind( "HH" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.find_last_of( "hH" );                                // short
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "nN" );                                // int (natural number)
+                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
+                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
+                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
+          FINI: ;
+                // This declaration and the comma expressions in the conditions mimic
+                // the declare and check pattern allowed in later compiler versions.
+                // (Only some early compilers/C++ standards do not support it.)
+                string::size_type posn;
+                // pointer value
+                if ( posn = str.find_last_of( "pP" ), posn != string::npos ) {
+                        ltype = 5; str.erase( posn, 1 );
+                // size_t
+                } else if ( posn = str.find_last_of( "zZ" ), posn != string::npos ) {
+                        Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 );
+                // signed char
+                } else if ( posn = str.rfind( "hh" ), posn != string::npos ) {
+                        type = 1; str.erase( posn, 2 );
+                // signed char
+                } else if ( posn = str.rfind( "HH" ), posn != string::npos ) {
+                        type = 1; str.erase( posn, 2 );
+                // short
+                } else if ( posn = str.find_last_of( "hH" ), posn != string::npos ) {
+                        type = 0; str.erase( posn, 1 );
+                // int (natural number)
+                } else if ( posn = str.find_last_of( "nN" ), posn != string::npos ) {
+                        type = 2; str.erase( posn, 1 );
+                } else if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) {
+                        type = 4;
+                } else {
+                        lnthSuffix( str, type, ltype );
+                } // if
         } // if
 …
         if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str );
 #endif // ! __SIZEOF_INT128__
         if ( str[0] == '0' ) {                                                          // radix character ?
                 dec = false;
 …
                                 unsigned int len = str.length();
                                 if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
+                          if ( len <= (2 + 16) ) goto FHEX1;            // hex digits < 2^64
+                                str2 = "0x" + str.substr( len - 16 );
+                                sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                str = str.substr( 0, len - 16 );
+                          FHEX1: ;
+                                // hex digits < 2^64
+                                if ( len > (2 + 16) ) {
+                                        str2 = "0x" + str.substr( len - 16 );
+                                        sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                        str = str.substr( 0, len - 16 );
+                                } // if
                                 sscanf( (char *)str.c_str(), "%llx", &v );
 #endif // __SIZEOF_INT128__
 …
         // Constant type is correct for overload resolving.
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
+        ret = new ast::ConstantExpr( location,
+                new ast::BasicType( kind[Unsigned][type] ), str, v );
         if ( Unsigned && type < 2 ) {                                           // hh or h, less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                ret = new ast::CastExpr( location,
+                        ret,
+                        new ast::BasicType( kind[Unsigned][type] ),
+                        ast::ExplicitCast );
         } else if ( ltype != -1 ) {                                                     // explicit length ?
                 if ( ltype == 6 ) {                                                             // int128, (int128)constant
+//                      ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                        ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) );
+                        ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                                                                 new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
+                        ret2 = new ast::ConstantExpr( location,
+                                new ast::BasicType( ast::BasicType::LongLongSignedInt ),
+                                str2,
+                                v2 );
+                        ret = build_compoundLiteral( location,
+                                DeclarationNode::newBasicType(
+                                        DeclarationNode::Int128
+                                )->addType(
+                                        DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                new InitializerNode(
+                                        (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true )
+                        );
                 } else {                                                                                // explicit length, (length_type)constant
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
+                        ret = new ast::CastExpr( location,
+                                ret,
+                                new ast::TypeInstType( lnthsInt[Unsigned][ltype], ast::TypeDecl::Dtype ),
+                                ast::ExplicitCast );
                         if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant )
+                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );
+                                ret = build_func( location,
+                                        new ExpressionNode(
+                                                build_varref( location, new string( "intptr" ) ) ),
+                                        new ExpressionNode( ret ) );
                         } // if
                 } // if
 …
+Expression * build_constantFloat( string & str ) {
+        static const BasicType::Kind kind[2][12] = {
+                { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x },
+                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
+ast::Expr * build_constantFloat(
+                const CodeLocation & location, string & str ) {
+        static const ast::BasicType::Kind kind[2][12] = {
+                { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x },
+                { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex },
         };
 …
         assert( 0 <= type && type < 12 );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][type] ), str, v ) );
+        if ( explnth ) {                                                                        // explicit length ?
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][type] ), false );
+        ast::Expr * ret = new ast::ConstantExpr( location,
+                new ast::BasicType( kind[complx][type] ),
+                str,
+                v );
+        // explicit length ?
+        if ( explnth ) {
+                ret = new ast::CastExpr( location,
+                        ret,
+                        new ast::BasicType( kind[complx][type] ),
+                        ast::ExplicitCast );
         } // if
 …
 } // sepString
 Expression * build_constantChar( string & str ) {
+ast::Expr * build_constantChar( const CodeLocation & location, string & str ) {
         string units;                                                                           // units
         sepString( str, units, '\'' );                                          // separate constant from units
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
+        ast::Expr * ret = new ast::ConstantExpr( location,
+                new ast::BasicType( ast::BasicType::Char ),
+                str,
+                (unsigned long long int)(unsigned char)str[1] );
         if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new ast::UntypedExpr( location,
+                        new ast::NameExpr( location, units ),
+                        { ret } );
         } // if
 …
 } // build_constantChar
+Expression * build_constantStr( string & str ) {
+ast::Expr * build_constantStr(
+                const CodeLocation & location,
+                string & str ) {
         assert( str.length() > 0 );
         string units;                                                                           // units
         sepString( str, units, '"' );                                           // separate constant from units
         Type * strtype;
+        ast::Type * strtype;
         switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1
           case 'u':
+        case 'u':
                 if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
                 // lookup type of associated typedef
                 strtype = new TypeInstType( Type::Qualifiers( ), "char16_t", false );
+                strtype = new ast::TypeInstType( "char16_t", ast::TypeDecl::Dtype );
                 break;
           case 'U':
                 strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false );
+        case 'U':
+                strtype = new ast::TypeInstType( "char32_t", ast::TypeDecl::Dtype );
                 break;
           case 'L':
                 strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false );
+        case 'L':
+                strtype = new ast::TypeInstType( "wchar_t", ast::TypeDecl::Dtype );
                 break;
           Default:                                                                                      // char default string type
           default:
                 strtype = new BasicType( Type::Qualifiers( ), BasicType::Char );
+        Default:                                                                                        // char default string type
+        default:
+                strtype = new ast::BasicType( ast::BasicType::Char );
         } // switch
+        ArrayType * at = new ArrayType( noQualifiers, strtype,
+                                                                        new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
+                                                                        false, false );
+        Expression * ret = new ConstantExpr( Constant( at, str, std::nullopt ) );
+        ast::ArrayType * at = new ast::ArrayType(
+                strtype,
+                // Length is adjusted: +1 for '\0' and -2 for '"'
+                ast::ConstantExpr::from_ulong( location, str.size() + 1 - 2 ),
+                ast::FixedLen,
+                ast::DynamicDim );
+        ast::Expr * ret = new ast::ConstantExpr( location, at, str, std::nullopt );
         if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new ast::UntypedExpr( location,
+                        new ast::NameExpr( location, units ),
+                        { ret } );
         } // if
 …
 } // build_constantStr
+Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATING_FRACTIONconstant(
+                const CodeLocation & location, const string & str ) {
         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) SemanticError( yylloc, "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
+        ast::Expr * ret = build_constantInteger( location,
+                *new string( str.substr(1) ) );
         delete &str;
         return ret;
 } // build_field_name_FLOATING_FRACTIONconstant
+Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATING_DECIMALconstant(
+                const CodeLocation & location, const string & str ) {
         if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
+        ast::Expr * ret = build_constantInteger(
+                location, *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;
         return ret;
 } // build_field_name_FLOATING_DECIMALconstant
+Expression * build_field_name_FLOATINGconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATINGconstant( const CodeLocation & location,
+                const string & str ) {
         // str is of the form A.B -> separate at the . and return member expression
         int a, b;
 …
         stringstream ss( str );
         ss >> a >> dot >> b;
+        UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
+        auto ret = new ast::UntypedMemberExpr( location,
+                ast::ConstantExpr::from_int( location, b ),
+                ast::ConstantExpr::from_int( location, a )
+        );
         delete &str;
         return ret;
 } // build_field_name_FLOATINGconstant
+Expression * make_field_name_fraction_constants( Expression * fieldName, Expression * fracts ) {
+        if ( fracts ) {
+                if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( fracts ) ) {
+                        memberExpr->set_member( make_field_name_fraction_constants( fieldName, memberExpr->get_aggregate() ) );
+                        return memberExpr;
+                } else {
+                        return new UntypedMemberExpr( fracts, fieldName );
+                } // if
+        } // if
+        return fieldName;
+ast::Expr * make_field_name_fraction_constants( const CodeLocation & location,
+                ast::Expr * fieldName,
+                ast::Expr * fracts ) {
+        if ( nullptr == fracts ) {
+                return fieldName;
+        } else if ( auto memberExpr = dynamic_cast<ast::UntypedMemberExpr *>( fracts ) ) {
+                memberExpr->member = make_field_name_fraction_constants( location,
+                        fieldName,
+                        ast::mutate( memberExpr->aggregate.get() ) );
+                return memberExpr;
+        } else {
+                return new ast::UntypedMemberExpr( location, fracts, fieldName );
+        } // if
 } // make_field_name_fraction_constants
+Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
+        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
+ast::Expr * build_field_name_fraction_constants( const CodeLocation & location,
+                ast::Expr * fieldName,
+                ExpressionNode * fracts ) {
+        return make_field_name_fraction_constants( location, fieldName, maybeMoveBuild( fracts ) );
 } // build_field_name_fraction_constants
+NameExpr * build_varref( const string * name ) {
+        NameExpr * expr = new NameExpr( *name );
+ast::NameExpr * build_varref( const CodeLocation & location,
+                const string * name ) {
+        ast::NameExpr * expr = new ast::NameExpr( location, *name );
         delete name;
         return expr;
 } // build_varref
+QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node);
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
+                const Type * t = newDeclWithType->get_type();
+                if ( t ) {
+                        if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) {
+                                newDecl= new EnumDecl( typeInst->name );
+ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation & location,
+                const DeclarationNode * decl_node,
+                const ast::NameExpr * name ) {
+        ast::Decl * newDecl = maybeBuild( decl_node );
+        if ( ast::DeclWithType * newDeclWithType = dynamic_cast<ast::DeclWithType *>( newDecl ) ) {
+                if ( const ast::Type * t = newDeclWithType->get_type() ) {
+                        if ( auto typeInst = dynamic_cast<const ast::TypeInstType *>( t ) ) {
+                                newDecl = new ast::EnumDecl( location, typeInst->name );
+                        }
+                }
+        }
         return new QualifiedNameExpr( newDecl, name->name );
+        return new ast::QualifiedNameExpr( location, newDecl, name->name );
+}
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) {
+        EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node );
+        return new QualifiedNameExpr( newDecl, name->name );
+ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation & location,
+                const ast::EnumDecl * decl,
+                const ast::NameExpr * name ) {
+        return new ast::QualifiedNameExpr( location, decl, name->name );
+}
+DimensionExpr * build_dimensionref( const string * name ) {
+        DimensionExpr * expr = new DimensionExpr( *name );
+ast::DimensionExpr * build_dimensionref( const CodeLocation & location,
+                const string * name ) {
+        ast::DimensionExpr * expr = new ast::DimensionExpr( location, *name );
         delete name;
         return expr;
 …
 }; // OperName
+Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        Type * targetType = maybeMoveBuildType( decl_node );
+        if ( dynamic_cast< VoidType * >( targetType ) ) {
+ast::Expr * build_cast( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ExpressionNode * expr_node ) {
+        ast::Type * targetType = maybeMoveBuildType( decl_node );
+        if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
                 delete targetType;
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
+                return new ast::CastExpr( location,
+                        maybeMoveBuild( expr_node ),
+                        ast::ExplicitCast );
         } else {
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
+                return new ast::CastExpr( location,
+                        maybeMoveBuild( expr_node ),
+                        targetType,
+                        ast::ExplicitCast );
         } // if
 } // build_cast
+Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node ) {
+        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+ast::Expr * build_keyword_cast( const CodeLocation & location,
+                ast::AggregateDecl::Aggregate target,
+                ExpressionNode * expr_node ) {
+        return new ast::KeywordCastExpr( location,
+                maybeMoveBuild( expr_node ),
+                target
+        );
+}
+Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
+ast::Expr * build_virtual_cast( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ExpressionNode * expr_node ) {
+        return new ast::VirtualCastExpr( location,
+                maybeMoveBuild( expr_node ),
+                maybeMoveBuildType( decl_node )
+        );
 } // build_virtual_cast
+Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
+        return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+ast::Expr * build_fieldSel( const CodeLocation & location,
+                ExpressionNode * expr_node,
+                ast::Expr * member ) {
+        return new ast::UntypedMemberExpr( location,
+                member,
+                maybeMoveBuild( expr_node )
+        );
 } // build_fieldSel
+Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+ast::Expr * build_pfieldSel( const CodeLocation & location,
+                ExpressionNode * expr_node,
+                ast::Expr * member ) {
+        auto deref = new ast::UntypedExpr( location,
+                new ast::NameExpr( location, "*?" )
+        );
         deref->location = expr_node->location;
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
         UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
+        deref->args.push_back( maybeMoveBuild( expr_node ) );
+        auto ret = new ast::UntypedMemberExpr( location, member, deref );
         return ret;
 } // build_pfieldSel
+Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
+        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
+ast::Expr * build_offsetOf( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ast::NameExpr * member ) {
+        ast::Expr * ret = new ast::UntypedOffsetofExpr( location,
+                maybeMoveBuildType( decl_node ),
+                member->name
+        );
+        ret->result = new ast::BasicType( ast::BasicType::LongUnsignedInt );
         delete member;
         return ret;
 } // build_offsetOf
+Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
+        return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
+ast::Expr * build_and_or( const CodeLocation & location,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2,
+                ast::LogicalFlag flag ) {
+        return new ast::LogicalExpr( location,
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                notZeroExpr( maybeMoveBuild( expr_node2 ) ),
+                flag
+        );
 } // build_and_or
+Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
+        list< Expression * > args;
+        args.push_back( maybeMoveBuild< Expression >(expr_node) );
+        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+ast::Expr * build_unary_val( const CodeLocation & location,
+                OperKinds op,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> args;
+        args.push_back( maybeMoveBuild( expr_node ) );
+        return new ast::UntypedExpr( location,
+                new ast::NameExpr( location, OperName[ (int)op ] ),
+                std::move( args )
+        );
 } // build_unary_val
+Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
         list< Expression * > args;
         args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_unary_ptr
+Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+ast::Expr * build_binary_val( const CodeLocation & location,
+                OperKinds op,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2 ) {
+        std::vector<ast::ptr<ast::Expr>> args;
+        args.push_back( maybeMoveBuild( expr_node1 ) );
+        args.push_back( maybeMoveBuild( expr_node2 ) );
+        return new ast::UntypedExpr( location,
+                new ast::NameExpr( location, OperName[ (int)op ] ),
+                std::move( args )
+        );
 } // build_binary_val
+Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_binary_ptr
+Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) {
         return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
+ast::Expr * build_cond( const CodeLocation & location,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2,
+                ExpressionNode * expr_node3 ) {
+        return new ast::ConditionalExpr( location,
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                maybeMoveBuild( expr_node2 ),
+                maybeMoveBuild( expr_node3 )
+        );
 } // build_cond
+Expression * build_tuple( ExpressionNode * expr_node ) {
+        list< Expression * > exprs;
+ast::Expr * build_tuple( const CodeLocation & location,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> exprs;
         buildMoveList( expr_node, exprs );
         return new UntypedTupleExpr( exprs );;
+        return new ast::UntypedTupleExpr( location, std::move( exprs ) );
 } // build_tuple
+Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
+        list< Expression * > args;
+ast::Expr * build_func( const CodeLocation & location,
+                ExpressionNode * function,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> args;
         buildMoveList( expr_node, args );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
+        return new ast::UntypedExpr( location,
+                maybeMoveBuild( function ),
+                std::move( args )
+        );
 } // build_func
+Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
+ast::Expr * build_compoundLiteral( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                InitializerNode * kids ) {
+        // compound literal type
+        ast::Decl * newDecl = maybeBuild( decl_node );
+        // non-sue compound-literal type
+        if ( ast::DeclWithType * newDeclWithType = dynamic_cast<ast::DeclWithType *>( newDecl ) ) {
+                return new ast::CompoundLiteralExpr( location,
+                        newDeclWithType->get_type(),
+                        maybeMoveBuild( kids ) );
         // these types do not have associated type information
+        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
+                if ( newDeclStructDecl->has_body() ) {
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) );
+        } else if ( auto newDeclStructDecl = dynamic_cast<ast::StructDecl *>( newDecl ) ) {
+                if ( newDeclStructDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::StructInstType( newDeclStructDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                } // if
+        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
+                if ( newDeclUnionDecl->has_body() ) {
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::StructInstType( newDeclStructDecl->name ),
+                                maybeMoveBuild( kids ) );
+                } // if
+        } else if ( auto newDeclUnionDecl = dynamic_cast<ast::UnionDecl *>( newDecl )  ) {
+                if ( newDeclUnionDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::UnionInstType( newDeclUnionDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                } // if
+        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
+                if ( newDeclEnumDecl->has_body() ) {
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::UnionInstType( newDeclUnionDecl->name ),
+                                maybeMoveBuild( kids ) );
+                } // if
+        } else if ( auto newDeclEnumDecl = dynamic_cast<ast::EnumDecl *>( newDecl )  ) {
+                if ( newDeclEnumDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::EnumInstType( newDeclEnumDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::EnumInstType( newDeclEnumDecl->name ),
+                                maybeMoveBuild( kids ) );
                 } // if
         } else {
 …
 // Local Variables: //
 // tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
 // End: //

src/Parser/InitializerNode.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 28 23:27:20 2017
 // Update Count     : 26
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:18:00 2023
+// Update Count     : 27
 //
+#include "InitializerNode.h"
 #include <iostream>                // for operator<<, ostream, basic_ostream
 …
 #include <string>                  // for operator<<, string
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Init.hpp"            // for Designator, Init, ListInit, Sing...
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ExpressionNode.h"        // for ExpressionNode
+#include "DeclarationNode.h"       // for buildList
 using namespace std;
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ParseNode.h"             // for InitializerNode, ExpressionNode
+#include "SynTree/Expression.h"    // for Expression
+#include "SynTree/Initializer.h"   // for Initializer, ListInit, SingleInit
+static ast::ConstructFlag toConstructFlag( bool maybeConstructed ) {
+        return maybeConstructed ? ast::MaybeConstruct : ast::NoConstruct;
+}
 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
 …
         if ( kids )
                 set_last( nullptr );
 } // InitializerNode::InitializerNode
+} // InitializerNode::InitializerNode
 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
 …
 } // InitializerNode::printOneLine
 Initializer * InitializerNode::build() const {
+ast::Init * InitializerNode::build() const {
         assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
         if ( aggregate ) {
                 // steal designators from children
                 std::list< Designation * > designlist;
+                std::vector<ast::ptr<ast::Designation>> designlist;
                 InitializerNode * child = next_init();
+                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::list< Expression * > desList;
+                        buildList< Expression, ExpressionNode >( child->designator, desList );
+                        designlist.push_back( new Designation( desList ) );
+                for ( ; child != nullptr ; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::deque<ast::ptr<ast::Expr>> desList;
+                        buildList( child->designator, desList );
+                        designlist.push_back(
+                                new ast::Designation( location, std::move( desList ) ) );
                 } // for
+                std::list< Initializer * > initlist;
+                buildList< Initializer, InitializerNode >( next_init(), initlist );
+                return new ListInit( initlist, designlist, maybeConstructed );
+        } else {
+                if ( get_expression() ) {
+                        assertf( get_expression()->expr, "The expression of initializer must have value" );
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                } // if
+                std::vector<ast::ptr<ast::Init>> initlist;
+                buildList( next_init(), initlist );
+                return new ast::ListInit( location,
+                        std::move( initlist ),
+                        std::move( designlist ),
+                        toConstructFlag( maybeConstructed )
+                );
+        } else if ( get_expression() ) {
+                assertf( get_expression()->expr, "The expression of initializer must have value" );
+                return new ast::SingleInit( location,
+                        maybeBuild( get_expression() ),
+                        toConstructFlag( maybeConstructed )
+                );
         } // if
         return nullptr;

src/Parser/ParseNode.h

-              r2ed94a9
+              rb110bcc
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov  2 21:27:07 2022
 // Update Count     : 939
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr  3 17:55:00 2023
+// Update Count     : 942
 //
 …
 #include <string>                  // for string
+#include "AST/Expr.hpp"            // for Expr, NameExpr LogicalFlag
+#include "AST/Fwd.hpp"             // for ptr, Decl, DeclWithType,
+#include "AST/Stmt.hpp"            // for Stmt
 #include "Common/CodeLocation.h"   // for CodeLocation
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild
+#include "SynTree/LinkageSpec.h"   // for Spec
+#include "SynTree/Declaration.h"   // for Aggregate
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
+#include "SynTree/Label.h"         // for Label
+#include "SynTree/Statement.h"     // for Statement, BranchStmt, BranchStmt:...
+#include "SynTree/Type.h"          // for Type, Type::FuncSpecifiers, Type::...
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/parserutility.h"  // for maybeBuild, maybeCopy
 class Attribute;
 …
 class DeclarationWithType;
 class Initializer;
+class InitializerNode;
 class ExpressionNode;
 struct StatementNode;
 …
 }; // ParseNode
-//##############################################################################
-class InitializerNode : public ParseNode {
-  public:
-        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
-        InitializerNode( bool isDelete );
-        ~InitializerNode();
-        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
-        ExpressionNode * get_expression() const { return expr; }
-        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
-        ExpressionNode * get_designators() const { return designator; }
-        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
-        bool get_maybeConstructed() const { return maybeConstructed; }
-        bool get_isDelete() const { return isDelete; }
-        InitializerNode * next_init() const { return kids; }
-        void print( std::ostream & os, int indent = 0 ) const;
-        void printOneLine( std::ostream & ) const;
-        virtual Initializer * build() const;
-  private:
-        ExpressionNode * expr;
-        bool aggregate;
-        ExpressionNode * designator;                                            // may be list
-        InitializerNode * kids;
-        bool maybeConstructed;
-        bool isDelete;
-}; // InitializerNode
-//##############################################################################
-class ExpressionNode final : public ParseNode {
-  public:
-        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
-        virtual ~ExpressionNode() {}
-        virtual ExpressionNode * clone() const override { return expr ? static_cast<ExpressionNode*>((new ExpressionNode( expr->clone() ))->set_next( maybeClone( get_next() ) )) : nullptr; }
-        bool get_extension() const { return extension; }
-        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
-        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
-                os << expr.get();
+        }
-        void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
-        template<typename T>
-        bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
-        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
-        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
-  private:
-        bool extension = false;
-}; // ExpressionNode
-template< typename T >
-struct maybeBuild_t< Expression, T > {
-        static inline Expression * doit( const T * orig ) {
-                if ( orig ) {
-                        Expression * p = orig->build();
-                        p->set_extension( orig->get_extension() );
-                        p->location = orig->location;
-                        return p;
-                } else {
-                        return nullptr;
-                } // if
+        }
-};
 // Must harmonize with OperName.
 enum class OperKinds {
 …
 struct LabelNode {
         std::list< Label > labels;
+        std::vector<ast::Label> labels;
 };
-Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
-Expression * build_constantFloat( std::string & str );
-Expression * build_constantChar( std::string & str );
-Expression * build_constantStr( std::string & str );
-Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
-Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
-Expression * build_field_name_FLOATINGconstant( const std::string & str );
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
-NameExpr * build_varref( const std::string * name );
-QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
-QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
-DimensionExpr * build_dimensionref( const std::string * name );
-Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
-Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
-Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
-Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
-Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
-Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
-Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
-Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
-Expression * build_tuple( ExpressionNode * expr_node = nullptr );
-Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
-Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
-//##############################################################################
-struct TypeData;
-struct DeclarationNode : public ParseNode {
-        // These enumerations must harmonize with their names in DeclarationNode.cc.
-        enum BasicType { Void, Bool, Char, Int, Int128,
-                                         Float, Double, LongDouble, uuFloat80, uuFloat128,
-                                         uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
-        static const char * basicTypeNames[];
-        enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
-        static const char * complexTypeNames[];
-        enum Signedness { Signed, Unsigned, NoSignedness };
-        static const char * signednessNames[];
-        enum Length { Short, Long, LongLong, NoLength };
-        static const char * lengthNames[];
-        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
-        static const char * builtinTypeNames[];
-        static DeclarationNode * newStorageClass( Type::StorageClasses );
-        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
-        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
-        static DeclarationNode * newBasicType( BasicType );
-        static DeclarationNode * newComplexType( ComplexType );
-        static DeclarationNode * newSignedNess( Signedness );
-        static DeclarationNode * newLength( Length );
-        static DeclarationNode * newBuiltinType( BuiltinType );
-        static DeclarationNode * newForall( DeclarationNode * );
-        static DeclarationNode * newFromTypedef( const std::string * );
-        static DeclarationNode * newFromGlobalScope();
-        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
-        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
-        static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
-        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
-        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
-        static DeclarationNode * newEnumInLine( const std::string name );
-        static DeclarationNode * newName( const std::string * );
-        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
-        static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
-        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
-        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
-        static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
-        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
-        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
-        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
-        static DeclarationNode * newBitfield( ExpressionNode * size );
-        static DeclarationNode * newTuple( DeclarationNode * members );
-        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
-        static DeclarationNode * newVtableType( DeclarationNode * expr );
-        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
-        static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
-        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
-        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
-        DeclarationNode();
-        ~DeclarationNode();
-        DeclarationNode * clone() const override;
-        DeclarationNode * addQualifiers( DeclarationNode * );
-        void checkQualifiers( const TypeData *, const TypeData * );
-        void checkSpecifiers( DeclarationNode * );
-        DeclarationNode * copySpecifiers( DeclarationNode * );
-        DeclarationNode * addType( DeclarationNode * );
-        DeclarationNode * addTypedef();
-        DeclarationNode * addEnumBase( DeclarationNode * );
-        DeclarationNode * addAssertions( DeclarationNode * );
-        DeclarationNode * addName( std::string * );
-        DeclarationNode * addAsmName( DeclarationNode * );
-        DeclarationNode * addBitfield( ExpressionNode * size );
-        DeclarationNode * addVarArgs();
-        DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
-        DeclarationNode * addOldDeclList( DeclarationNode * list );
-        DeclarationNode * setBase( TypeData * newType );
-        DeclarationNode * copyAttribute( DeclarationNode * attr );
-        DeclarationNode * addPointer( DeclarationNode * qualifiers );
-        DeclarationNode * addArray( DeclarationNode * array );
-        DeclarationNode * addNewPointer( DeclarationNode * pointer );
-        DeclarationNode * addNewArray( DeclarationNode * array );
-        DeclarationNode * addParamList( DeclarationNode * list );
-        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
-        DeclarationNode * addInitializer( InitializerNode * init );
-        DeclarationNode * addTypeInitializer( DeclarationNode * init );
-        DeclarationNode * cloneType( std::string * newName );
-        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
-        DeclarationNode * appendList( DeclarationNode * node ) {
-                return (DeclarationNode *)set_last( node );
+        }
-        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
-        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
-        Declaration * build() const;
-        Type * buildType() const;
-        LinkageSpec::Spec get_linkage() const { return linkage; }
-        DeclarationNode * extractAggregate() const;
-        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
-        bool get_extension() const { return extension; }
-        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
-        bool get_inLine() const { return inLine; }
-        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
-        DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
-        struct Variable_t {
-//              const std::string * name;
-                TypeDecl::Kind tyClass;
-                DeclarationNode * assertions;
-                DeclarationNode * initializer;
-        };
-        Variable_t variable;
-        struct Attr_t {
-//              const std::string * name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-        Attr_t attr;
-        struct StaticAssert_t {
-                ExpressionNode * condition;
-                Expression * message;
-        };
-        StaticAssert_t assert;
-        BuiltinType builtin = NoBuiltinType;
-        TypeData * type = nullptr;
-        bool inLine = false;
-        bool enumInLine = false;
-        Type::FuncSpecifiers funcSpecs;
-        Type::StorageClasses storageClasses;
-        ExpressionNode * bitfieldWidth = nullptr;
-        std::unique_ptr<ExpressionNode> enumeratorValue;
-        bool hasEllipsis = false;
-        LinkageSpec::Spec linkage;
-        Expression * asmName = nullptr;
-        std::list< Attribute * > attributes;
-        InitializerNode * initializer = nullptr;
-        bool extension = false;
-        std::string error;
-        StatementNode * asmStmt = nullptr;
-        StatementNode * directiveStmt = nullptr;
-        static UniqueName anonymous;
-}; // DeclarationNode
-Type * buildType( TypeData * type );
-static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
-        Type * ret = orig ? orig->buildType() : nullptr;
-        delete orig;
-        return ret;
+}
-//##############################################################################
-struct StatementNode final : public ParseNode {
-        StatementNode() { stmt = nullptr; }
-        StatementNode( Statement * stmt ) : stmt( stmt ) {}
-        StatementNode( DeclarationNode * decl );
-        virtual ~StatementNode() {}
-        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
-        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
-        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
-                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
-                delete attr;
-                delete name;
-                return this;
+        }
-        virtual StatementNode * append_last_case( StatementNode * );
-        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
-                os << stmt.get() << std::endl;
+        }
-        std::unique_ptr<Statement> stmt;
-}; // StatementNode
-Statement * build_expr( ExpressionNode * ctl );
-struct CondCtl {
-        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
-                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
-        StatementNode * init;
-        ExpressionNode * condition;
-};
-struct ForCtrl {
-        ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
-                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
-        ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
-                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
-        StatementNode * init;
-        ExpressionNode * condition;
-        ExpressionNode * change;
-};
-Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
-Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
-Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
-Statement * build_case( ExpressionNode * ctl );
-Statement * build_default();
-Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_branch( BranchStmt::Type kind );
-Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
-Statement * build_computedgoto( ExpressionNode * ctl );
-Statement * build_return( ExpressionNode * ctl );
-Statement * build_throw( ExpressionNode * ctl );
-Statement * build_resume( ExpressionNode * ctl );
-Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
-Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
-Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
-Statement * build_finally( StatementNode * stmt );
-Statement * build_compound( StatementNode * first );
-StatementNode * maybe_build_compound( StatementNode * first );
-Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
-Statement * build_directive( std::string * directive );
-SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
-Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
-Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
-//##############################################################################
-template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
-void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
-        SemanticErrorException errors;
-        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
-        const NodeType * cur = firstNode;
-        while ( cur ) {
-                try {
-                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
-                        if ( result ) {
-                                result->location = cur->location;
-                                * out++ = result;
-                        } else {
-                                SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
-                        } // if
-                } catch( SemanticErrorException & e ) {
-                        errors.append( e );
-                } // try
-                const ParseNode * temp = (cur->get_next());
-                cur = dynamic_cast< const NodeType * >( temp ); // should not return nullptr
-                if ( ! cur && temp ) {                                                  // non-homogeneous nodes ?
-                        SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
-                } // if
-        } // while
-        if ( ! errors.isEmpty() ) {
-                throw errors;
-        } // if
+}
-// in DeclarationNode.cc
-void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList );
-void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList );
-void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList );
-template< typename SynTreeType, typename NodeType >
-void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
-        buildList( firstNode, outputList );
-        delete firstNode;
+}
-// in ParseNode.cc
 std::ostream & operator<<( std::ostream & out, const ParseNode * node );

src/Parser/ParserTypes.h

-              r2ed94a9
+              rb110bcc
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // parser.hh --
 //
+//
+// parser.hh --
+//
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep 22 08:58:10 2001

src/Parser/RunParser.cpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon Dec 19 11:00:00 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Dec 22 10:18:00 2022
 // Update Count     : 1
+// Last Modified On : Mon Mar  6  9:42:00 2023
+// Update Count     : 3
 //
 …
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Parser/ParseNode.h"               // for DeclarationNode, buildList
+#include "Parser/DeclarationNode.h"         // for DeclarationNode, buildList
 #include "Parser/TypedefTable.h"            // for TypedefTable
 // Variables global to the parsing code.
 LinkageSpec::Spec linkage = LinkageSpec::Cforall;
+ast::Linkage::Spec linkage = ast::Linkage::Cforall;
 TypedefTable typedefTable;
 DeclarationNode * parseTree = nullptr;
 void parse( FILE * input, LinkageSpec::Spec linkage, bool alwaysExit ) {
+void parse( FILE * input, ast::Linkage::Spec linkage, bool alwaysExit ) {
         extern int yyparse( void );
         extern FILE * yyin;
 …
 ast::TranslationUnit buildUnit(void) {
+        std::list<Declaration *> translationUnit;
+        buildList( parseTree, translationUnit );
+        std::vector<ast::ptr<ast::Decl>> decls;
+        buildList( parseTree, decls );
         delete parseTree;
         parseTree = nullptr;
+        // When the parse/buildList code is translated to the new ast, these
+        // fill passes (and the one after 'Hoist Type Decls') should be redundent
+        // because the code locations should already be filled.
+        CodeTools::fillLocations( translationUnit );
+        ast::TranslationUnit transUnit = convert( std::move( translationUnit ) );
+        forceFillCodeLocations( transUnit );
+        ast::TranslationUnit transUnit;
+        for ( auto decl : decls ) {
+                transUnit.decls.emplace_back( std::move( decl ) );
+        }
         return transUnit;
+}

src/Parser/RunParser.hpp

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon Dec 19 10:42:00 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Dec 22 10:23:00 2022
 // Update Count     : 1
+// Last Modified On : Thr Feb 16 10:08:00 2023
+// Update Count     : 2
 //
 …
 #include <iosfwd>                           // for ostream
 #include "SynTree/LinkageSpec.h"            // for Spec
+#include "AST/LinkageSpec.hpp"              // for Spec
 namespace ast {
         class TranslationUnit;
 …
 /// The input file is closed when complete. Exits instead of returning on
 /// error or if alwaysExit is true.
 void parse( FILE * input, LinkageSpec::Spec linkage, bool alwaysExit = false );
+void parse( FILE * input, ast::Linkage::Spec linkage, bool alwaysExit = false );
 /// Drain the internal accumulator of parsed code and build a translation

src/Parser/StatementNode.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb  2 20:29:30 2022
 // Update Count     : 425
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 11 10:16:00 2023
+// Update Count     : 428
 //
+#include "StatementNode.h"
 #include <cassert>                 // for assert, strict_dynamic_cast, assertf
-#include <list>                    // for list
 #include <memory>                  // for unique_ptr
 #include <string>                  // for string
+#include "AST/Label.hpp"           // for Label
+#include "AST/Stmt.hpp"            // for Stmt, AsmStmt, BranchStmt, CaseCla...
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild
+#include "ParseNode.h"             // for StatementNode, ExpressionNode, bui...
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr
+#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Declaration.h"
+#include "SynTree/Statement.h"     // for Statement, BranchStmt, CaseStmt
+#include "DeclarationNode.h"       // for DeclarationNode
+#include "ExpressionNode.h"        // for ExpressionNode
 #include "parserutility.h"         // for notZeroExpr
 …
 using namespace std;
+// Some helpers for cases that really want a single node but check for lists.
+static const ast::Stmt * buildMoveSingle( StatementNode * node ) {
+        std::vector<ast::ptr<ast::Stmt>> list;
+        buildMoveList( node, list );
+        assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" );
+        return list.front().release();
+}
+static const ast::Stmt * buildMoveOptional( StatementNode * node ) {
+        std::vector<ast::ptr<ast::Stmt>> list;
+        buildMoveList( node, list );
+        assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" );
+        return list.empty() ? nullptr : list.front().release();
+}
 StatementNode::StatementNode( DeclarationNode * decl ) {
 …
         DeclarationNode * agg = decl->extractAggregate();
         if ( agg ) {
+                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode * nextStmt = new StatementNode(
+                        new ast::DeclStmt( decl->location, maybeBuild( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
 …
                 agg = decl;
         } // if
+        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
+        // Local copy to avoid accessing the pointer after it is moved from.
+        CodeLocation declLocation = agg->location;
+        stmt.reset( new ast::DeclStmt( declLocation, maybeMoveBuild( agg ) ) );
 } // StatementNode::StatementNode
+StatementNode * StatementNode::append_last_case( StatementNode * stmt ) {
+        StatementNode * prev = this;
+StatementNode * StatementNode::add_label(
+                const CodeLocation & location,
+                const std::string * name,
+                DeclarationNode * attr ) {
+        stmt->labels.emplace_back( location,
+                *name,
+                attr ? std::move( attr->attributes )
+                        : std::vector<ast::ptr<ast::Attribute>>{} );
+        delete attr;
+        delete name;
+        return this;
+}
+ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) {
+        ClauseNode * prev = this;
         // find end of list and maintain previous pointer
         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
                 StatementNode * node = strict_dynamic_cast< StatementNode * >(curr);
                 assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
+        for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) {
+                ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr);
+                assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) );
                 prev = curr;
         } // for
+        ClauseNode * node = dynamic_cast< ClauseNode * >(prev);
         // convert from StatementNode list to Statement list
+        StatementNode * node = dynamic_cast< StatementNode * >(prev);
+        list< Statement * > stmts;
+        std::vector<ast::ptr<ast::Stmt>> stmts;
         buildMoveList( stmt, stmts );
         // splice any new Statements to end of current Statements
+        CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt.get());
+        caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
+        auto caseStmt = strict_dynamic_cast<ast::CaseClause *>( node->clause.get() );
+        for ( auto const & newStmt : stmts ) {
+                caseStmt->stmts.emplace_back( newStmt );
+        }
+        stmts.clear();
         return this;
+} // StatementNode::append_last_case
+Statement * build_expr( ExpressionNode * ctl ) {
+        Expression * e = maybeMoveBuild< Expression >( ctl );
+        if ( e ) return new ExprStmt( e );
+        else return new NullStmt();
+} // ClauseNode::append_last_case
+ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) {
+        if ( ast::Expr * e = maybeMoveBuild( ctl ) ) {
+                return new ast::ExprStmt( location, e );
+        } else {
+                return new ast::NullStmt( location );
+        }
 } // build_expr
+Expression * build_if_control( CondCtl * ctl, list< Statement * > & init ) {
+        if ( ctl->init != 0 ) {
+                buildMoveList( ctl->init, init );
+static ast::Expr * build_if_control( CondCtl * ctl,
+                std::vector<ast::ptr<ast::Stmt>> & inits ) {
+        assert( inits.empty() );
+        if ( nullptr != ctl->init ) {
+                buildMoveList( ctl->init, inits );
         } // if
         Expression * cond = nullptr;
+        ast::Expr * cond = nullptr;
         if ( ctl->condition ) {
                 // compare the provided condition against 0
                 cond = notZeroExpr( maybeMoveBuild< Expression >(ctl->condition) );
+                cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
         } else {
                 for ( Statement * stmt : init ) {
+                for ( ast::ptr<ast::Stmt> & stmt : inits ) {
                         // build the && of all of the declared variables compared against 0
                         DeclStmt * declStmt = strict_dynamic_cast< DeclStmt * >( stmt );
                         DeclarationWithType * dwt = strict_dynamic_cast< DeclarationWithType * >( declStmt->decl );
                         Expression * nze = notZeroExpr( new VariableExpr( dwt ) );
                         cond = cond ? new LogicalExpr( cond, nze, true ) : nze;
+                        auto declStmt = stmt.strict_as<ast::DeclStmt>();
+                        auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
+                        ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
+                        cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze;
+                }
+        }
 …
 } // build_if_control
+Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        Statement * astthen, * astelse = nullptr;
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( then, aststmt );
+        assert( aststmt.size() == 1 );
+        astthen = aststmt.front();
+        if ( else_ ) {
+                list< Statement * > aststmt;
+                buildMoveList< Statement, StatementNode >( else_, aststmt );
+                assert( aststmt.size() == 1 );
+                astelse = aststmt.front();
+        } // if
+        return new IfStmt( astcond, astthen, astelse, astinit );
+ast::Stmt * build_if( const CodeLocation & location, CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        ast::Stmt const * astthen = buildMoveSingle( then );
+        ast::Stmt const * astelse = buildMoveOptional( else_ );
+        return new ast::IfStmt( location, astcond, astthen, astelse,
+                std::move( astinit )
+        );
 } // build_if
+Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        if ( ! isSwitch ) {                                                                     // choose statement
+                for ( Statement * stmt : aststmt ) {
+                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
+                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
+                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
+                                block->kids.push_back( new BranchStmt( "", BranchStmt::Break ) );
+ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) {
+        std::vector<ast::ptr<ast::CaseClause>> aststmt;
+        buildMoveList( stmt, aststmt );
+        // If it is not a switch it is a choose statement.
+        if ( ! isSwitch ) {
+                for ( ast::ptr<ast::CaseClause> & stmt : aststmt ) {
+                        // Code after "case" is the end of case list.
+                        if ( !stmt->stmts.empty() ) {
+                                auto mutStmt = ast::mutate( stmt.get() );
+                                // I believe the stmts are actually always one block.
+                                auto stmts = mutStmt->stmts.front().get_and_mutate();
+                                auto block = strict_dynamic_cast<ast::CompoundStmt *>( stmts );
+                                block->kids.push_back( new ast::BranchStmt( block->location,
+                                        ast::BranchStmt::Break,
+                                        ast::Label( block->location ) ) );
+                                stmt = mutStmt;
                         } // if
                 } // for
         } // if
         // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
+        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
+        return new ast::SwitchStmt( location,
+                maybeMoveBuild( ctl ), std::move( aststmt ) );
 } // build_switch
+Statement * build_case( ExpressionNode * ctl ) {
+        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
+ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) {
+        // stmt starts empty and then added to
+        auto expr = maybeMoveBuild( ctl );
+        return new ast::CaseClause( location, expr, {} );
 } // build_case
+Statement * build_default() {
+        return new CaseStmt( nullptr, {}, true );                       // stmt starts empty and then added to
+ast::CaseClause * build_default( const CodeLocation & location ) {
+        // stmt starts empty and then added to
+        return new ast::CaseClause( location, nullptr, {} );
 } // build_default
+Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+        return new WhileDoStmt( astcond, aststmt.front(), astelse.front(), astinit, false );
+ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        return new ast::WhileDoStmt( location,
+                astcond,
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ ),
+                std::move( astinit ),
+                ast::While
+        );
 } // build_while
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );                                          // compound created if empty
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
         // do-while cannot have declarations in the contitional, so init is always empty
+        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true );
+        return new ast::WhileDoStmt( location,
+                notZeroExpr( maybeMoveBuild( ctl ) ),
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ ),
+                {},
+                ast::DoWhile
+        );
 } // build_do_while
 Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
         list< Statement * > astinit;                                            // maybe empty
+ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
         buildMoveList( forctl->init, astinit );
         Expression * astcond = nullptr;                                         // maybe empty
         astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
         Expression * astincr = nullptr;                                         // maybe empty
         astincr = maybeMoveBuild< Expression >(forctl->change);
+        ast::Expr * astcond = nullptr;                                          // maybe empty
+        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        ast::Expr * astincr = nullptr;                                          // maybe empty
+        astincr = maybeMoveBuild( forctl->change );
         delete forctl;
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+        return new ForStmt( astinit, astcond, astincr, aststmt.front(), astelse.front() );
+        return new ast::ForStmt( location,
+                std::move( astinit ),
+                astcond,
+                astincr,
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ )
+        );
 } // build_for
+Statement * build_branch( BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( "", kind );
+        return ret;
+ast::Stmt * build_branch( const CodeLocation & location, ast::BranchStmt::Kind kind ) {
+        return new ast::BranchStmt( location,
+                kind,
+                ast::Label( location )
+        );
 } // build_branch
+Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( * identifier, kind );
+ast::Stmt * build_branch( const CodeLocation & location, string * identifier, ast::BranchStmt::Kind kind ) {
+        ast::Stmt * ret = new ast::BranchStmt( location,
+                kind,
+                ast::Label( location, *identifier )
+        );
         delete identifier;                                                                      // allocated by lexer
         return ret;
 } // build_branch
+Statement * build_computedgoto( ExpressionNode * ctl ) {
+        return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+ast::Stmt * build_computedgoto( ExpressionNode * ctl ) {
+        ast::Expr * expr = maybeMoveBuild( ctl );
+        return new ast::BranchStmt( expr->location, expr );
 } // build_computedgoto
 Statement * build_return( ExpressionNode * ctl ) {
         list< Expression * > exps;
+ast::Stmt * build_return( const CodeLocation & location, ExpressionNode * ctl ) {
+        std::vector<ast::ptr<ast::Expr>> exps;
         buildMoveList( ctl, exps );
+        return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
+        return new ast::ReturnStmt( location,
+                exps.size() > 0 ? exps.back().release() : nullptr
+        );
 } // build_return
+Statement * build_throw( ExpressionNode * ctl ) {
+        list< Expression * > exps;
+static ast::Stmt * build_throw_stmt(
+                const CodeLocation & location,
+                ExpressionNode * ctl,
+                ast::ExceptionKind kind ) {
+        std::vector<ast::ptr<ast::Expr>> exps;
         buildMoveList( ctl, exps );
         assertf( exps.size() < 2, "CFA internal error: leaking memory" );
+        return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+        return new ast::ThrowStmt( location,
+                kind,
+                !exps.empty() ? exps.back().release() : nullptr,
+                (ast::Expr *)nullptr
+        );
+}
+ast::Stmt * build_throw( const CodeLocation & loc, ExpressionNode * ctl ) {
+        return build_throw_stmt( loc, ctl, ast::Terminate );
 } // build_throw
+Statement * build_resume( ExpressionNode * ctl ) {
+        list< Expression * > exps;
+        buildMoveList( ctl, exps );
+        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
+        return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+ast::Stmt * build_resume( const CodeLocation & loc, ExpressionNode * ctl ) {
+        return build_throw_stmt( loc, ctl, ast::Resume );
 } // build_resume
 Statement * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
+ast::Stmt * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
         (void)ctl;
         (void)target;
 …
 } // build_resume_at
+Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) {
+        list< CatchStmt * > aststmt;
+        buildMoveList< CatchStmt, StatementNode >( catch_, aststmt );
+        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_));
+        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) );
+        return new TryStmt( tryBlock, aststmt, finallyBlock );
+ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) {
+        std::vector<ast::ptr<ast::CatchClause>> aststmt;
+        buildMoveList( catch_, aststmt );
+        ast::CompoundStmt * tryBlock = strict_dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( try_ ) );
+        ast::FinallyClause * finallyBlock = nullptr;
+        if ( finally_ ) {
+                finallyBlock = dynamic_cast<ast::FinallyClause *>( finally_->clause.release() );
+        }
+        return new ast::TryStmt( location,
+                tryBlock,
+                std::move( aststmt ),
+                finallyBlock
+        );
 } // build_try
+Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( body, aststmt );
+        assert( aststmt.size() == 1 );
+        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
+ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        return new ast::CatchClause( location,
+                kind,
+                maybeMoveBuild( decl ),
+                maybeMoveBuild( cond ),
+                buildMoveSingle( body )
+        );
 } // build_catch
+Statement * build_finally( StatementNode * stmt ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        return new FinallyStmt( dynamic_cast< CompoundStmt * >( aststmt.front() ) );
+ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) {
+        return new ast::FinallyClause( location,
+                strict_dynamic_cast<const ast::CompoundStmt *>(
+                        buildMoveSingle( stmt )
+                )
+        );
 } // build_finally
+SuspendStmt * build_suspend( StatementNode * then, SuspendStmt::Type type ) {
+        auto node = new SuspendStmt();
+        node->type = type;
+        list< Statement * > stmts;
+        buildMoveList< Statement, StatementNode >( then, stmts );
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                node->then = dynamic_cast< CompoundStmt * >( stmts.front() );
+        }
+        return node;
+}
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) {
+        return new ast::SuspendStmt( location,
+                strict_dynamic_cast<const ast::CompoundStmt *, nullptr>(
+                        buildMoveOptional( then )
+                ),
+                kind
+        );
+} // build_suspend
+ast::WaitForStmt * build_waitfor( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
+        auto clause = new ast::WaitForClause( location );
+        clause->target_func = maybeBuild( targetExpr );
+        clause->stmt = maybeMoveBuild( stmt );
+        clause->cond = notZeroExpr( maybeMoveBuild( when ) );
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
         targetExpr->set_next( nullptr );
         buildMoveList< Expression >( next, target.arguments );
+        buildMoveList( next, clause->target_args );
         delete targetExpr;
+        node->clauses.push_back( WaitForStmt::Clause{
+                target,
+                maybeMoveBuild<Statement >( stmt ),
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+        });
+        return node;
+        existing->clauses.insert( existing->clauses.begin(), clause );
+        return existing;
 } // build_waitfor
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+        ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
+        targetExpr->set_next( nullptr );
+        buildMoveList< Expression >( next, target.arguments );
+        delete targetExpr;
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
+                std::move( target ),
+                maybeMoveBuild<Statement >( stmt ),
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+        });
+        return node;
+} // build_waitfor
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+        if( timeout ) {
+                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        } else {
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        } // if
+        return node;
+ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) {
+        existing->else_stmt = maybeMoveBuild( stmt );
+        existing->else_cond = notZeroExpr( maybeMoveBuild( when ) );
+        (void)location;
+        return existing;
+} // build_waitfor_else
+ast::WaitForStmt * build_waitfor_timeout( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
+        existing->timeout_time = maybeMoveBuild( timeout );
+        existing->timeout_stmt = maybeMoveBuild( stmt );
+        existing->timeout_cond = notZeroExpr( maybeMoveBuild( when ) );
+        (void)location;
+        return existing;
 } // build_waitfor_timeout
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_, ExpressionNode * else_when ) {
+        auto node = new WaitForStmt();
+        node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+        node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        node->orelse.statement  = maybeMoveBuild<Statement >( else_ );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
+        return node;
+} // build_waitfor_timeout
+Statement * build_with( ExpressionNode * exprs, StatementNode * stmt ) {
+        list< Expression * > e;
+ast::Stmt * build_with( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Expr>> e;
         buildMoveList( exprs, e );
         Statement * s = maybeMoveBuild<Statement>( stmt );
         return new DeclStmt( new WithStmt( e, s ) );
+        ast::Stmt * s = maybeMoveBuild( stmt );
+        return new ast::DeclStmt( location, new ast::WithStmt( location, std::move( e ), s ) );
 } // build_with
 Statement * build_compound( StatementNode * first ) {
         CompoundStmt * cs = new CompoundStmt();
         buildMoveList( first, cs->get_kids() );
+ast::Stmt * build_compound( const CodeLocation & location, StatementNode * first ) {
+        auto cs = new ast::CompoundStmt( location );
+        buildMoveList( first, cs->kids );
         return cs;
 } // build_compound
 …
 // statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a
 // conical form for code generation.
 StatementNode * maybe_build_compound( StatementNode * first ) {
+StatementNode * maybe_build_compound( const CodeLocation & location, StatementNode * first ) {
         // Optimization: if the control-structure statement is a compound statement, do not wrap it.
         // e.g., if (...) {...} do not wrap the existing compound statement.
+        if ( ! dynamic_cast<CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                CompoundStmt * cs = new CompoundStmt();
+                buildMoveList( first, cs->get_kids() );
+                return new StatementNode( cs );
+        if ( !dynamic_cast<ast::CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                return new StatementNode( build_compound( location, first ) );
         } // if
         return first;
 …
 // Question
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         list< Expression * > out, in;
         list< ConstantExpr * > clob;
+ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
+        std::vector<ast::ptr<ast::Expr>> out, in;
+        std::vector<ast::ptr<ast::ConstantExpr>> clob;
         buildMoveList( output, out );
         buildMoveList( input, in );
         buildMoveList( clobber, clob );
+        return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+        return new ast::AsmStmt( location,
+                is_volatile,
+                maybeMoveBuild( instruction ),
+                std::move( out ),
+                std::move( in ),
+                std::move( clob ),
+                gotolabels ? gotolabels->labels : std::vector<ast::Label>()
+        );
 } // build_asm
+Statement * build_directive( string * directive ) {
+        return new DirectiveStmt( *directive );
+ast::Stmt * build_directive( const CodeLocation & location, string * directive ) {
+        auto stmt = new ast::DirectiveStmt( location, *directive );
+        delete directive;
+        return stmt;
 } // build_directive
 Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
         list< Expression * > expList;
+ast::Stmt * build_mutex( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Expr>> expList;
         buildMoveList( exprs, expList );
         Statement * body = maybeMoveBuild<Statement>( stmt );
         return new MutexStmt( body, expList );
+        ast::Stmt * body = maybeMoveBuild( stmt );
+        return new ast::MutexStmt( location, body, std::move( expList ) );
 } // build_mutex

src/Parser/TypeData.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:36:52 2022
 // Update Count     : 677
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 13:39:00 2023
+// Update Count     : 680
 //
+#include "TypeData.h"
 #include <cassert>                 // for assert
 #include <ostream>                 // for operator<<, ostream, basic_ostream
+#include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
+#include "AST/Init.hpp"            // for SingleInit, ListInit
+#include "AST/Print.hpp"           // for print
 #include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeClone, maybeBuild, maybeMoveB...
+#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, FunctionDecl
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
+#include "SynTree/Initializer.h"   // for SingleInit, Initializer (ptr only)
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement
+#include "SynTree/Type.h"          // for BasicType, Type, Type::ForallList
+#include "TypeData.h"
+#include "Common/utility.h"        // for splice, spliceBegin
+#include "Parser/ExpressionNode.h" // for ExpressionNode
+#include "Parser/StatementNode.h"  // for StatementNode
 class Attribute;
 …
 TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
         switch ( kind ) {
+          case Unknown:
+          case Pointer:
+          case Reference:
+          case EnumConstant:
+          case GlobalScope:
+                // nothing else to initialize
+                break;
+          case Basic:
+                // basic = new Basic_t;
+                break;
+          case Array:
+                // array = new Array_t;
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Basic:
+                // No unique data to initialize.
+                break;
+        case Array:
                 array.dimension = nullptr;
                 array.isVarLen = false;
                 array.isStatic = false;
                 break;
+          case Function:
+                // function = new Function_t;
+        case Function:
                 function.params = nullptr;
                 function.idList = nullptr;
 …
                 function.withExprs = nullptr;
                 break;
+                // Enum is an Aggregate, so both structures are initialized together.
+          case Enum:
+                // enumeration = new Enumeration_t;
+        case Enum:
                 enumeration.name = nullptr;
                 enumeration.constants = nullptr;
 …
                 enumeration.anon = false;
                 break;
+          case Aggregate:
+                // aggregate = new Aggregate_t;
+                aggregate.kind = AggregateDecl::NoAggregate;
+        case Aggregate:
+                aggregate.kind = ast::AggregateDecl::NoAggregate;
                 aggregate.name = nullptr;
                 aggregate.params = nullptr;
 …
                 aggregate.anon = false;
                 break;
+          case AggregateInst:
+                // aggInst = new AggInst_t;
+        case AggregateInst:
                 aggInst.aggregate = nullptr;
                 aggInst.params = nullptr;
                 aggInst.hoistType = false;
                 break;
+          case Symbolic:
+          case SymbolicInst:
+                // symbolic = new Symbolic_t;
+        case Symbolic:
+        case SymbolicInst:
                 symbolic.name = nullptr;
                 symbolic.params = nullptr;
 …
                 symbolic.assertions = nullptr;
                 break;
+          case Tuple:
+                // tuple = new Tuple_t;
+        case Tuple:
                 tuple = nullptr;
                 break;
+          case Typeof:
+          case Basetypeof:
+                // typeexpr = new Typeof_t;
+        case Typeof:
+        case Basetypeof:
                 typeexpr = nullptr;
                 break;
           case Vtable:
                 break;
           case Builtin:
                 // builtin = new Builtin_t;
                 case Qualified:
+        case Vtable:
+        case Builtin:
+                // No unique data to initialize.
+                break;
+        case Qualified:
                 qualified.parent = nullptr;
                 qualified.child = nullptr;
 …
         switch ( kind ) {
+          case Unknown:
+          case Pointer:
+          case Reference:
+          case EnumConstant:
+          case GlobalScope:
+                // nothing to destroy
+                break;
+          case Basic:
+                // delete basic;
+                break;
+          case Array:
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Basic:
+                // No unique data to deconstruct.
+                break;
+        case Array:
                 delete array.dimension;
+                // delete array;
+                break;
+          case Function:
+                break;
+        case Function:
                 delete function.params;
                 delete function.idList;
 …
                 delete function.body;
                 delete function.withExprs;
+                // delete function;
+                break;
+          case Aggregate:
+                break;
+        case Aggregate:
                 delete aggregate.name;
                 delete aggregate.params;
                 delete aggregate.actuals;
                 delete aggregate.fields;
+                // delete aggregate;
+                break;
+          case AggregateInst:
+                break;
+        case AggregateInst:
                 delete aggInst.aggregate;
                 delete aggInst.params;
+                // delete aggInst;
+                break;
+          case Enum:
+                break;
+        case Enum:
                 delete enumeration.name;
                 delete enumeration.constants;
+                // delete enumeration;
+                break;
+          case Symbolic:
+          case SymbolicInst:
+                break;
+        case Symbolic:
+        case SymbolicInst:
                 delete symbolic.name;
                 delete symbolic.params;
                 delete symbolic.actuals;
                 delete symbolic.assertions;
+                // delete symbolic;
+                break;
+          case Tuple:
+                // delete tuple->members;
+                break;
+        case Tuple:
                 delete tuple;
                 break;
+          case Typeof:
+          case Basetypeof:
+                // delete typeexpr->expr;
+        case Typeof:
+        case Basetypeof:
                 delete typeexpr;
                 break;
+          case Vtable:
+                break;
+          case Builtin:
+                // delete builtin;
+                break;
+          case Qualified:
+        case Vtable:
+        case Builtin:
+                // No unique data to deconstruct.
+                break;
+        case Qualified:
                 delete qualified.parent;
                 delete qualified.child;
+                break;
         } // switch
 } // TypeData::~TypeData
 …
         switch ( kind ) {
           case Unknown:
           case EnumConstant:
           case Pointer:
           case Reference:
           case GlobalScope:
+        case Unknown:
+        case EnumConstant:
+        case Pointer:
+        case Reference:
+        case GlobalScope:
                 // nothing else to copy
                 break;
           case Basic:
+        case Basic:
                 newtype->basictype = basictype;
                 newtype->complextype = complextype;
 …
                 newtype->length = length;
                 break;
           case Array:
+        case Array:
                 newtype->array.dimension = maybeClone( array.dimension );
                 newtype->array.isVarLen = array.isVarLen;
                 newtype->array.isStatic = array.isStatic;
                 break;
           case Function:
+        case Function:
                 newtype->function.params = maybeClone( function.params );
                 newtype->function.idList = maybeClone( function.idList );
 …
                 newtype->function.withExprs = maybeClone( function.withExprs );
                 break;
           case Aggregate:
+        case Aggregate:
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
 …
                 newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 break;
           case AggregateInst:
+        case AggregateInst:
                 newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
                 newtype->aggInst.params = maybeClone( aggInst.params );
                 newtype->aggInst.hoistType = aggInst.hoistType;
                 break;
           case Enum:
+        case Enum:
                 newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
                 newtype->enumeration.constants = maybeClone( enumeration.constants );
 …
                 newtype->enumeration.anon = enumeration.anon;
                 break;
           case Symbolic:
           case SymbolicInst:
+        case Symbolic:
+        case SymbolicInst:
                 newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
                 newtype->symbolic.params = maybeClone( symbolic.params );
 …
                 newtype->symbolic.isTypedef = symbolic.isTypedef;
                 break;
           case Tuple:
+        case Tuple:
                 newtype->tuple = maybeClone( tuple );
                 break;
           case Typeof:
           case Basetypeof:
+        case Typeof:
+        case Basetypeof:
                 newtype->typeexpr = maybeClone( typeexpr );
                 break;
           case Vtable:
                 break;
           case Builtin:
+        case Vtable:
+                break;
+        case Builtin:
                 assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One );
                 newtype->builtintype = builtintype;
                 break;
                 case Qualified:
+        case Qualified:
                 newtype->qualified.parent = maybeClone( qualified.parent );
                 newtype->qualified.child = maybeClone( qualified.child );
 …
 void TypeData::print( ostream &os, int indent ) const {
+        for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
+                if ( qualifiers[i] ) os << Type::QualifiersNames[ i ] << ' ';
+        } // for
+        ast::print( os, qualifiers );
         if ( forall ) {
 …
         switch ( kind ) {
           case Basic:
+        case Basic:
                 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
                 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
 …
                 if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " ";
                 break;
           case Pointer:
+        case Pointer:
                 os << "pointer ";
                 if ( base ) {
 …
                 } // if
                 break;
           case Reference:
+        case Reference:
                 os << "reference ";
                 if ( base ) {
 …
                 } // if
                 break;
           case Array:
+        case Array:
                 if ( array.isStatic ) {
                         os << "static ";
 …
                 } // if
                 break;
           case Function:
+        case Function:
                 os << "function" << endl;
                 if ( function.params ) {
 …
                 } // if
                 break;
           case Aggregate:
                 os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
+        case Aggregate:
+                os << ast::AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters" << endl;
 …
                 } // if
                 break;
           case AggregateInst:
+        case AggregateInst:
                 if ( aggInst.aggregate ) {
                         os << "instance of " ;
 …
                 } // if
                 break;
           case Enum:
                 os << "enumeration ";
+        case Enum:
+                os << "enumeration " << *enumeration.name << endl;;
                 if ( enumeration.constants ) {
                         os << "with constants" << endl;
 …
                 } // if
                 break;
           case EnumConstant:
+        case EnumConstant:
                 os << "enumeration constant ";
                 break;
           case Symbolic:
+        case Symbolic:
                 if ( symbolic.isTypedef ) {
                         os << "typedef definition ";
 …
                 } // if
                 break;
           case SymbolicInst:
+        case SymbolicInst:
                 os << *symbolic.name;
                 if ( symbolic.actuals ) {
 …
                 } // if
                 break;
           case Tuple:
+        case Tuple:
                 os << "tuple ";
                 if ( tuple ) {
 …
                 } // if
                 break;
           case Basetypeof:
+        case Basetypeof:
                 os << "base-";
                 #if defined(__GNUC__) && __GNUC__ >= 7
 …
                 #endif
                 // FALL THROUGH
           case Typeof:
+        case Typeof:
                 os << "type-of expression ";
                 if ( typeexpr ) {
 …
                 } // if
                 break;
           case Vtable:
+        case Vtable:
                 os << "vtable";
                 break;
           case Builtin:
+        case Builtin:
                 os << DeclarationNode::builtinTypeNames[builtintype];
                 break;
           case GlobalScope:
                 break;
           case Qualified:
+        case GlobalScope:
+                break;
+        case Qualified:
                 qualified.parent->print( os );
                 os << ".";
                 qualified.child->print( os );
                 break;
           case Unknown:
+        case Unknown:
                 os << "entity of unknown type ";
                 break;
           default:
+        default:
                 os << "internal error: TypeData::print " << kind << endl;
                 assert( false );
 …
 const std::string * TypeData::leafName() const {
         switch ( kind ) {
           case Unknown:
           case Pointer:
           case Reference:
           case EnumConstant:
           case GlobalScope:
           case Array:
           case Basic:
           case Function:
           case AggregateInst:
           case Tuple:
           case Typeof:
           case Basetypeof:
           case Builtin:
           case Vtable:
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Array:
+        case Basic:
+        case Function:
+        case AggregateInst:
+        case Tuple:
+        case Typeof:
+        case Basetypeof:
+        case Builtin:
+        case Vtable:
                 assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
                 break;
           case Aggregate:
+        case Aggregate:
                 return aggregate.name;
           case Enum:
+        case Enum:
                 return enumeration.name;
           case Symbolic:
           case SymbolicInst:
+        case Symbolic:
+        case SymbolicInst:
                 return symbolic.name;
           case Qualified:
+        case Qualified:
                 return qualified.child->leafName();
         } // switch
 …
+template< typename ForallList >
+void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
+        buildList( firstNode, outputList );
+void buildForall(
+                const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::TypeInstType>> &outputList ) {
+        {
+                std::vector<ast::ptr<ast::Type>> tmpList;
+                buildTypeList( firstNode, tmpList );
+                for ( auto tmp : tmpList ) {
+                        outputList.emplace_back(
+                                strict_dynamic_cast<const ast::TypeInstType *>(
+                                        tmp.release() ) );
+                }
+        }
         auto n = firstNode;
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
+                TypeDecl * td = static_cast<TypeDecl *>(*i);
+                if ( n->variable.tyClass == TypeDecl::Otype ) {
+                        // add assertion parameters to `type' tyvars in reverse order
+                        // add dtor:  void ^?{}(T *)
+                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
+                        // add copy ctor:  void ?{}(T *, T)
+                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
+                        // add default ctor:  void ?{}(T *)
+                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
+                        // add assignment operator:  T * ?=?(T *, T)
+                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
+                } // if
+        for ( auto i = outputList.begin() ;
+                        i != outputList.end() ;
+                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                // Only the object type class adds additional assertions.
+                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
+                        continue;
+                }
+                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
+                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
+                auto mutTypeDecl = ast::mutate( td );
+                const CodeLocation & location = mutTypeDecl->location;
+                *i = mutTypeDecl;
+                // add assertion parameters to `type' tyvars in reverse order
+                // add assignment operator:  T * ?=?(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?=?",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add default ctor:  void ?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add copy ctor:  void ?{}(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add dtor:  void ^?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "^?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                spliceBegin( mutTypeDecl->assertions, newAssertions );
+        } // for
+}
+void buildForall(
+                const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::TypeDecl>> &outputForall ) {
+        buildList( firstNode, outputForall );
+        auto n = firstNode;
+        for ( auto i = outputForall.begin() ;
+                        i != outputForall.end() ;
+                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                // Only the object type class adds additional assertions.
+                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
+                        continue;
+                }
+                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
+                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
+                auto mutTypeDecl = ast::mutate( td );
+                const CodeLocation & location = mutTypeDecl->location;
+                *i = mutTypeDecl;
+                // add assertion parameters to `type' tyvars in reverse order
+                // add assignment operator:  T * ?=?(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?=?",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( new ast::TypeInstType( td->name, *i ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add default ctor:  void ?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( td->name, i->get() ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add copy ctor:  void ?{}(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( td->name, *i ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add dtor:  void ^?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "^?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( i->get() )
+                                        ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                spliceBegin( mutTypeDecl->assertions, newAssertions );
         } // for
 } // buildForall
 Type * typebuild( const TypeData * td ) {
+ast::Type * typebuild( const TypeData * td ) {
         assert( td );
         switch ( td->kind ) {
           case TypeData::Unknown:
+        case TypeData::Unknown:
                 // fill in implicit int
+                return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+          case TypeData::Basic:
+                return new ast::BasicType(
+                        ast::BasicType::SignedInt,
+                        buildQualifiers( td )
+                );
+        case TypeData::Basic:
                 return buildBasicType( td );
           case TypeData::Pointer:
+        case TypeData::Pointer:
                 return buildPointer( td );
           case TypeData::Array:
+        case TypeData::Array:
                 return buildArray( td );
           case TypeData::Reference:
+        case TypeData::Reference:
                 return buildReference( td );
           case TypeData::Function:
                 return buildFunction( td );
           case TypeData::AggregateInst:
+        case TypeData::Function:
+                return buildFunctionType( td );
+        case TypeData::AggregateInst:
                 return buildAggInst( td );
           case TypeData::EnumConstant:
                 return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
+        case TypeData::EnumConstant:
+                return new ast::EnumInstType( "", buildQualifiers( td ) );
+        case TypeData::SymbolicInst:
                 return buildSymbolicInst( td );
           case TypeData::Tuple:
+        case TypeData::Tuple:
                 return buildTuple( td );
           case TypeData::Typeof:
           case TypeData::Basetypeof:
+        case TypeData::Typeof:
+        case TypeData::Basetypeof:
                 return buildTypeof( td );
           case TypeData::Vtable:
+        case TypeData::Vtable:
                 return buildVtable( td );
           case TypeData::Builtin:
+        case TypeData::Builtin:
                 switch ( td->builtintype ) {
                   case DeclarationNode::Zero:
                         return new ZeroType( noQualifiers );
                   case DeclarationNode::One:
                         return new OneType( noQualifiers );
                   default:
                         return new VarArgsType( buildQualifiers( td ) );
+                case DeclarationNode::Zero:
+                        return new ast::ZeroType();
+                case DeclarationNode::One:
+                        return new ast::OneType();
+                default:
+                        return new ast::VarArgsType( buildQualifiers( td ) );
                 } // switch
+          case TypeData::GlobalScope:
+                return new GlobalScopeType();
+          case TypeData::Qualified:
+                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+          case TypeData::Symbolic:
+          case TypeData::Enum:
+          case TypeData::Aggregate:
+        case TypeData::GlobalScope:
+                return new ast::GlobalScopeType();
+        case TypeData::Qualified:
+                return new ast::QualifiedType(
+                        typebuild( td->qualified.parent ),
+                        typebuild( td->qualified.child ),
+                        buildQualifiers( td )
+                );
+        case TypeData::Symbolic:
+        case TypeData::Enum:
+        case TypeData::Aggregate:
                 assert( false );
         } // switch
 …
         switch ( td->kind ) {
           case TypeData::Aggregate:
+        case TypeData::Aggregate:
                 if ( ! toplevel && td->aggregate.body ) {
                         ret = td->clone();
                 } // if
                 break;
           case TypeData::Enum:
+        case TypeData::Enum:
                 if ( ! toplevel && td->enumeration.body ) {
                         ret = td->clone();
                 } // if
                 break;
           case TypeData::AggregateInst:
+        case TypeData::AggregateInst:
                 if ( td->aggInst.aggregate ) {
                         ret = typeextractAggregate( td->aggInst.aggregate, false );
                 } // if
                 break;
           default:
+        default:
                 if ( td->base ) {
                         ret = typeextractAggregate( td->base, false );
 …
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
+ast::CV::Qualifiers buildQualifiers( const TypeData * td ) {
         return td->qualifiers;
 } // buildQualifiers
 …
 } // genTSError
 Type * buildBasicType( const TypeData * td ) {
         BasicType::Kind ret;
+ast::Type * buildBasicType( const TypeData * td ) {
+        ast::BasicType::Kind ret;
         switch ( td->basictype ) {
           case DeclarationNode::Void:
+        case DeclarationNode::Void:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 return new VoidType( buildQualifiers( td ) );
                 break;
           case DeclarationNode::Bool:
+                return new ast::VoidType( buildQualifiers( td ) );
+                break;
+        case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                 } // if
                 ret = BasicType::Bool;
                 break;
           case DeclarationNode::Char:
+                ret = ast::BasicType::Bool;
+                break;
+        case DeclarationNode::Char:
                 // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the
                 // character types. The implementation shall define char to have the same range, representation, and behavior as
                 // either signed char or unsigned char.
                 static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
+                static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
                 if ( td->length != DeclarationNode::NoLength ) {
 …
                 break;
           case DeclarationNode::Int:
                 static BasicType::Kind inttype[2][4] = {
                         { BasicType::ShortSignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt },
                         { BasicType::ShortUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt },
+        case DeclarationNode::Int:
+                static ast::BasicType::Kind inttype[2][4] = {
+                        { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
+                        { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
                 };
           Integral: ;
+        Integral: ;
                 if ( td->signedness == DeclarationNode::NoSignedness ) {
                         const_cast<TypeData *>(td)->signedness = DeclarationNode::Signed;
 …
                 break;
           case DeclarationNode::Int128:
                 ret = td->signedness == DeclarationNode::Unsigned ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+        case DeclarationNode::Int128:
+                ret = td->signedness == DeclarationNode::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
                 if ( td->length != DeclarationNode::NoLength ) {
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 …
                 break;
           case DeclarationNode::Float:
           case DeclarationNode::Double:
           case DeclarationNode::LongDouble:                                     // not set until below
           case DeclarationNode::uuFloat80:
           case DeclarationNode::uuFloat128:
           case DeclarationNode::uFloat16:
           case DeclarationNode::uFloat32:
           case DeclarationNode::uFloat32x:
           case DeclarationNode::uFloat64:
           case DeclarationNode::uFloat64x:
           case DeclarationNode::uFloat128:
           case DeclarationNode::uFloat128x:
                 static BasicType::Kind floattype[2][12] = {
                         { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex, },
                         { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x, },
+        case DeclarationNode::Float:
+        case DeclarationNode::Double:
+        case DeclarationNode::LongDouble:                                       // not set until below
+        case DeclarationNode::uuFloat80:
+        case DeclarationNode::uuFloat128:
+        case DeclarationNode::uFloat16:
+        case DeclarationNode::uFloat32:
+        case DeclarationNode::uFloat32x:
+        case DeclarationNode::uFloat64:
+        case DeclarationNode::uFloat64x:
+        case DeclarationNode::uFloat128:
+        case DeclarationNode::uFloat128x:
+                static ast::BasicType::Kind floattype[2][12] = {
+                        { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
+                        { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x, },
                 };
           FloatingPoint: ;
+        FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                 break;
           case DeclarationNode::NoBasicType:
+        case DeclarationNode::NoBasicType:
                 // No basic type in declaration => default double for Complex/Imaginary and int type for integral types
                 if ( td->complextype == DeclarationNode::Complex || td->complextype == DeclarationNode::Imaginary ) {
 …
                 const_cast<TypeData *>(td)->basictype = DeclarationNode::Int;
                 goto Integral;
           default:
                 assertf( false, "unknown basic type" );
+        default:
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
+        BasicType * bt = new BasicType( buildQualifiers( td ), ret );
+        buildForall( td->forall, bt->get_forall() );
+        ast::BasicType * bt = new ast::BasicType( ret, buildQualifiers( td ) );
         return bt;
 } // buildBasicType
 PointerType * buildPointer( const TypeData * td ) {
         PointerType * pt;
+ast::PointerType * buildPointer( const TypeData * td ) {
+        ast::PointerType * pt;
         if ( td->base ) {
+                pt = new PointerType( buildQualifiers( td ), typebuild( td->base ) );
+                pt = new ast::PointerType(
+                        typebuild( td->base ),
+                        buildQualifiers( td )
+                );
         } else {
+                pt = new PointerType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                pt = new ast::PointerType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, pt->get_forall() );
         return pt;
 } // buildPointer
 ArrayType * buildArray( const TypeData * td ) {
         ArrayType * at;
+ast::ArrayType * buildArray( const TypeData * td ) {
+        ast::ArrayType * at;
         if ( td->base ) {
+                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ),
+                                                        td->array.isVarLen, td->array.isStatic );
+                at = new ast::ArrayType(
+                        typebuild( td->base ),
+                        maybeBuild( td->array.dimension ),
+                        td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
+                        td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
+                        buildQualifiers( td )
+                );
         } else {
+                at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
+                                                        maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic );
+                at = new ast::ArrayType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        maybeBuild( td->array.dimension ),
+                        td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
+                        td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, at->get_forall() );
         return at;
 } // buildArray
 ReferenceType * buildReference( const TypeData * td ) {
         ReferenceType * rt;
+ast::ReferenceType * buildReference( const TypeData * td ) {
+        ast::ReferenceType * rt;
         if ( td->base ) {
+                rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) );
+                rt = new ast::ReferenceType(
+                        typebuild( td->base ),
+                        buildQualifiers( td )
+                );
         } else {
+                rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                rt = new ast::ReferenceType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, rt->get_forall() );
         return rt;
 } // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::AggregateDecl * buildAggregate( const TypeData * td, std::vector<ast::ptr<ast::Attribute>> attributes, ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
         AggregateDecl * at;
+        ast::AggregateDecl * at;
         switch ( td->aggregate.kind ) {
+          case AggregateDecl::Struct:
+          case AggregateDecl::Coroutine:
+          case AggregateDecl::Exception:
+          case AggregateDecl::Generator:
+          case AggregateDecl::Monitor:
+          case AggregateDecl::Thread:
+                at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage );
+                buildForall( td->aggregate.params, at->get_parameters() );
+                break;
+          case AggregateDecl::Union:
+                at = new UnionDecl( *td->aggregate.name, attributes, linkage );
+                buildForall( td->aggregate.params, at->get_parameters() );
+                break;
+          case AggregateDecl::Trait:
+                at = new TraitDecl( *td->aggregate.name, attributes, linkage );
+                buildList( td->aggregate.params, at->get_parameters() );
+                break;
+          default:
+        case ast::AggregateDecl::Struct:
+        case ast::AggregateDecl::Coroutine:
+        case ast::AggregateDecl::Exception:
+        case ast::AggregateDecl::Generator:
+        case ast::AggregateDecl::Monitor:
+        case ast::AggregateDecl::Thread:
+                at = new ast::StructDecl( td->location,
+                        *td->aggregate.name,
+                        td->aggregate.kind,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildForall( td->aggregate.params, at->params );
+                break;
+        case ast::AggregateDecl::Union:
+                at = new ast::UnionDecl( td->location,
+                        *td->aggregate.name,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildForall( td->aggregate.params, at->params );
+                break;
+        case ast::AggregateDecl::Trait:
+                at = new ast::TraitDecl( td->location,
+                        *td->aggregate.name,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildList( td->aggregate.params, at->params );
+                break;
+        default:
                 assert( false );
         } // switch
         buildList( td->aggregate.fields, at->get_members() );
+        buildList( td->aggregate.fields, at->members );
         at->set_body( td->aggregate.body );
 …
+ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::BaseInstType * buildComAggInst(
+                const TypeData * type,
+                std::vector<ast::ptr<ast::Attribute>> && attributes,
+                ast::Linkage::Spec linkage ) {
         switch ( type->kind ) {
+          case TypeData::Enum: {
+                  if ( type->enumeration.body ) {
+                          EnumDecl * typedecl = buildEnum( type, attributes, linkage );
+                          return new EnumInstType( buildQualifiers( type ), typedecl );
+                  } else {
+                          return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+                  } // if
+          }
+          case TypeData::Aggregate: {
+                  ReferenceToType * ret;
+                  if ( type->aggregate.body ) {
+                          AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
+                          switch ( type->aggregate.kind ) {
+                                case AggregateDecl::Struct:
+                                case AggregateDecl::Coroutine:
+                                case AggregateDecl::Monitor:
+                                case AggregateDecl::Thread:
+                                  ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
+                                  break;
+                                case AggregateDecl::Union:
+                                  ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
+                                  break;
+                                case AggregateDecl::Trait:
+                                  assert( false );
+                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
+                                  break;
+                                default:
+                                  assert( false );
+                          } // switch
+                  } else {
+                          switch ( type->aggregate.kind ) {
+                                case AggregateDecl::Struct:
+                                case AggregateDecl::Coroutine:
+                                case AggregateDecl::Monitor:
+                                case AggregateDecl::Thread:
+                                  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                case AggregateDecl::Union:
+                                  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                case AggregateDecl::Trait:
+                                  ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                default:
+                                  assert( false );
+                          } // switch
+                  } // if
+                  return ret;
+          }
+          default:
+        case TypeData::Enum:
+                if ( type->enumeration.body ) {
+                        ast::EnumDecl * typedecl =
+                                buildEnum( type, std::move( attributes ), linkage );
+                        return new ast::EnumInstType(
+                                typedecl,
+                                buildQualifiers( type )
+                        );
+                } else {
+                        return new ast::EnumInstType(
+                                *type->enumeration.name,
+                                buildQualifiers( type )
+                        );
+                } // if
+                break;
+        case TypeData::Aggregate:
+                if ( type->aggregate.body ) {
+                        ast::AggregateDecl * typedecl =
+                                buildAggregate( type, std::move( attributes ), linkage );
+                        switch ( type->aggregate.kind ) {
+                        case ast::AggregateDecl::Struct:
+                        case ast::AggregateDecl::Coroutine:
+                        case ast::AggregateDecl::Monitor:
+                        case ast::AggregateDecl::Thread:
+                                return new ast::StructInstType(
+                                        strict_dynamic_cast<ast::StructDecl *>( typedecl ),
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Union:
+                                return new ast::UnionInstType(
+                                        strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Trait:
+                                assert( false );
+                                break;
+                        default:
+                                assert( false );
+                        } // switch
+                } else {
+                        switch ( type->aggregate.kind ) {
+                        case ast::AggregateDecl::Struct:
+                        case ast::AggregateDecl::Coroutine:
+                        case ast::AggregateDecl::Monitor:
+                        case ast::AggregateDecl::Thread:
+                                return new ast::StructInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Union:
+                                return new ast::UnionInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Trait:
+                                return new ast::TraitInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        default:
+                                assert( false );
+                        } // switch
+                        break;
+                } // if
+                break;
+        default:
                 assert( false );
         } // switch
+        assert( false );
 } // buildAggInst
 ReferenceToType * buildAggInst( const TypeData * td ) {
+ast::BaseInstType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
+        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
+        ReferenceToType * ret = nullptr;
+        ast::BaseInstType * ret = nullptr;
         TypeData * type = td->aggInst.aggregate;
         switch ( type->kind ) {
+          case TypeData::Enum: {
+                  return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+          }
+          case TypeData::Aggregate: {
+                  switch ( type->aggregate.kind ) {
+                        case AggregateDecl::Struct:
+                        case AggregateDecl::Coroutine:
+                        case AggregateDecl::Monitor:
+                        case AggregateDecl::Thread:
+                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        case AggregateDecl::Union:
+                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        case AggregateDecl::Trait:
+                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        default:
+                          assert( false );
+                  } // switch
+          }
+          break;
+          default:
+        case TypeData::Enum:
+                return new ast::EnumInstType(
+                        *type->enumeration.name,
+                        buildQualifiers( type )
+                );
+        case TypeData::Aggregate:
+                switch ( type->aggregate.kind ) {
+                case ast::AggregateDecl::Struct:
+                case ast::AggregateDecl::Coroutine:
+                case ast::AggregateDecl::Monitor:
+                case ast::AggregateDecl::Thread:
+                        ret = new ast::StructInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                case ast::AggregateDecl::Union:
+                        ret = new ast::UnionInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                case ast::AggregateDecl::Trait:
+                        ret = new ast::TraitInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                default:
+                        assert( false );
+                } // switch
+                break;
+        default:
                 assert( false );
         } // switch
+        ret->set_hoistType( td->aggInst.hoistType );
+        buildList( td->aggInst.params, ret->get_parameters() );
+        buildForall( td->forall, ret->get_forall() );
+        ret->hoistType = td->aggInst.hoistType;
+        buildList( td->aggInst.params, ret->params );
         return ret;
 } // buildAggInst
+NamedTypeDecl * buildSymbolic( const TypeData * td, std::list< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
+ast::NamedTypeDecl * buildSymbolic(
+                const TypeData * td,
+                std::vector<ast::ptr<ast::Attribute>> attributes,
+                const std::string & name,
+                ast::Storage::Classes scs,
+                ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
+        ast::NamedTypeDecl * ret;
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
+                ret = new TypedefDecl( name, td->location, scs, typebuild( td->base ), linkage );
+                ret = new ast::TypedefDecl(
+                        td->location,
+                        name,
+                        scs,
+                        typebuild( td->base ),
+                        linkage
+                );
         } else {
+                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
+                ret = new ast::TypeDecl(
+                        td->location,
+                        name,
+                        scs,
+                        typebuild( td->base ),
+                        ast::TypeDecl::Dtype,
+                        true
+                );
         } // if
         buildList( td->symbolic.assertions, ret->get_assertions() );
         ret->base->attributes.splice( ret->base->attributes.end(), attributes );
+        buildList( td->symbolic.assertions, ret->assertions );
+        splice( ret->base.get_and_mutate()->attributes, attributes );
         return ret;
 } // buildSymbolic
+EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::EnumDecl * buildEnum(
+                const TypeData * td,
+                std::vector<ast::ptr<ast::Attribute>> && attributes,
+                ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
+        Type * baseType = td->base ? typebuild(td->base) : nullptr;
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType );
+        buildList( td->enumeration.constants, ret->get_members() );
+        list< Declaration * >::iterator members = ret->get_members().begin();
+        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? EnumDecl::EnumHiding::Hide : EnumDecl::EnumHiding::Visible;
+        ast::Type * baseType = td->base ? typebuild(td->base) : nullptr;
+        ast::EnumDecl * ret = new ast::EnumDecl(
+                td->location,
+                *td->enumeration.name,
+                td->enumeration.typed,
+                std::move( attributes ),
+                linkage,
+                baseType
+        );
+        buildList( td->enumeration.constants, ret->members );
+        auto members = ret->members.begin();
+        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
         for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->enumInLine ) {
 …
                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
                 } else if ( cur->has_enumeratorValue() ) {
+                        ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
+                        ast::Decl * member = members->get_and_mutate();
+                        ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
+                        object->init = new ast::SingleInit(
+                                td->location,
+                                maybeMoveBuild( cur->consume_enumeratorValue() ),
+                                ast::NoConstruct
+                        );
                 } else if ( !cur->initializer ) {
                         if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isInteger())) {
+                        if ( baseType && (!dynamic_cast<ast::BasicType *>(baseType) || !dynamic_cast<ast::BasicType *>(baseType)->isInteger())) {
                                 SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
+                        }
 …
                 // if
         } // for
         ret->set_body( td->enumeration.body );
+        ret->body = td->enumeration.body;
         return ret;
 } // buildEnum
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
+ast::TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
+        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
+        buildList( td->symbolic.actuals, ret->get_parameters() );
+        buildForall( td->forall, ret->get_forall() );
+        ast::TypeInstType * ret = new ast::TypeInstType(
+                *td->symbolic.name,
+                ast::TypeDecl::Dtype,
+                buildQualifiers( td )
+        );
+        buildList( td->symbolic.actuals, ret->params );
         return ret;
 } // buildSymbolicInst
 TupleType * buildTuple( const TypeData * td ) {
+ast::TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
         std::list< Type * > types;
+        std::vector<ast::ptr<ast::Type>> types;
         buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
+        buildForall( td->forall, ret->get_forall() );
+        ast::TupleType * ret = new ast::TupleType(
+                std::move( types ),
+                buildQualifiers( td )
+        );
         return ret;
 } // buildTuple
 TypeofType * buildTypeof( const TypeData * td ) {
+ast::TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
         assert( td->typeexpr );
+        // assert( td->typeexpr->expr );
+        return new TypeofType{ buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
+        return new ast::TypeofType(
+                td->typeexpr->build(),
+                td->kind == TypeData::Typeof
+                        ? ast::TypeofType::Typeof : ast::TypeofType::Basetypeof,
+                buildQualifiers( td )
+        );
 } // buildTypeof
 VTableType * buildVtable( const TypeData * td ) {
+ast::VTableType * buildVtable( const TypeData * td ) {
         assert( td->base );
+        return new VTableType{ buildQualifiers( td ), typebuild( td->base ) };
+        return new ast::VTableType(
+                typebuild( td->base ),
+                buildQualifiers( td )
+        );
 } // buildVtable
+Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+ast::FunctionDecl * buildFunctionDecl(
+                const TypeData * td,
+                const string &name,
+                ast::Storage::Classes scs,
+                ast::Function::Specs funcSpec,
+                ast::Linkage::Spec linkage,
+                ast::Expr * asmName,
+                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
+        assert( td->kind == TypeData::Function );
+        // For some reason FunctionDecl takes a bool instead of an ArgumentFlag.
+        bool isVarArgs = !td->function.params || td->function.params->hasEllipsis;
+        ast::CV::Qualifiers cvq = buildQualifiers( td );
+        std::vector<ast::ptr<ast::TypeDecl>> forall;
+        std::vector<ast::ptr<ast::DeclWithType>> assertions;
+        std::vector<ast::ptr<ast::DeclWithType>> params;
+        std::vector<ast::ptr<ast::DeclWithType>> returns;
+        buildList( td->function.params, params );
+        buildForall( td->forall, forall );
+        // Functions do not store their assertions there anymore.
+        for ( ast::ptr<ast::TypeDecl> & type_param : forall ) {
+                auto mut = type_param.get_and_mutate();
+                splice( assertions, mut->assertions );
+        }
+        if ( td->base ) {
+                switch ( td->base->kind ) {
+                case TypeData::Tuple:
+                        buildList( td->base->tuple, returns );
+                        break;
+                default:
+                        returns.push_back( dynamic_cast<ast::DeclWithType *>(
+                                buildDecl(
+                                        td->base,
+                                        "",
+                                        ast::Storage::Classes(),
+                                        (ast::Expr *)nullptr, // bitfieldWidth
+                                        ast::Function::Specs(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr // asmName
+                                )
+                        ) );
+                } // switch
+        } else {
+                returns.push_back( new ast::ObjectDecl(
+                        td->location,
+                        "",
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        (ast::Init *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+        } // if
+        ast::Stmt * stmt = maybeBuild( td->function.body );
+        ast::CompoundStmt * body = dynamic_cast<ast::CompoundStmt *>( stmt );
+        ast::FunctionDecl * decl = new ast::FunctionDecl( td->location,
+                name,
+                std::move( forall ),
+                std::move( assertions ),
+                std::move( params ),
+                std::move( returns ),
+                body,
+                scs,
+                linkage,
+                std::move( attributes ),
+                funcSpec,
+                (isVarArgs) ? ast::VariableArgs : ast::FixedArgs
+        );
+        buildList( td->function.withExprs, decl->withExprs );
+        decl->asmName = asmName;
+        // This may be redundant on a declaration.
+        decl->type.get_and_mutate()->qualifiers = cvq;
+        return decl;
+} // buildFunctionDecl
+ast::Decl * buildDecl(
+                const TypeData * td,
+                const string &name,
+                ast::Storage::Classes scs,
+                ast::Expr * bitfieldWidth,
+                ast::Function::Specs funcSpec,
+                ast::Linkage::Spec linkage,
+                ast::Expr * asmName,
+                ast::Init * init,
+                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
 …
                 } // if
+                FunctionDecl * decl;
+                Statement * stmt = maybeBuild<Statement>( td->function.body );
+                CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
+                decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
+                buildList( td->function.withExprs, decl->withExprs );
+                return decl->set_asmName( asmName );
+                return buildFunctionDecl(
+                        td, name, scs, funcSpec, linkage,
+                        asmName, std::move( attributes ) );
         } else if ( td->kind == TypeData::Aggregate ) {
                 return buildAggregate( td, attributes, linkage );
+                return buildAggregate( td, std::move( attributes ), linkage );
         } else if ( td->kind == TypeData::Enum ) {
                 return buildEnum( td, attributes, linkage );
+                return buildEnum( td, std::move( attributes ), linkage );
         } else if ( td->kind == TypeData::Symbolic ) {
                 return buildSymbolic( td, attributes, name, scs, linkage );
+                return buildSymbolic( td, std::move( attributes ), name, scs, linkage );
         } else {
+                return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
+                auto ret = new ast::ObjectDecl( td->location,
+                        name,
+                        typebuild( td ),
+                        init,
+                        scs,
+                        linkage,
+                        bitfieldWidth,
+                        std::move( attributes )
+                );
+                ret->asmName = asmName;
+                return ret;
         } // if
         return nullptr;
 …
 FunctionType * buildFunction( const TypeData * td ) {
+ast::FunctionType * buildFunctionType( const TypeData * td ) {
         assert( td->kind == TypeData::Function );
+        FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
+        buildList( td->function.params, ft->parameters );
+        ast::FunctionType * ft = new ast::FunctionType(
+                ( !td->function.params || td->function.params->hasEllipsis )
+                        ? ast::VariableArgs : ast::FixedArgs,
+                buildQualifiers( td )
+        );
+        buildTypeList( td->function.params, ft->params );
         buildForall( td->forall, ft->forall );
         if ( td->base ) {
                 switch ( td->base->kind ) {
                   case TypeData::Tuple:
                         buildList( td->base->tuple, ft->returnVals );
+                case TypeData::Tuple:
+                        buildTypeList( td->base->tuple, ft->returns );
                         break;
+                  default:
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
+                default:
+                        ft->returns.push_back( typebuild( td->base ) );
+                        break;
                 } // switch
         } else {
+                ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                ft->returns.push_back(
+                        new ast::BasicType( ast::BasicType::SignedInt ) );
         } // if
         return ft;
 } // buildFunction
+} // buildFunctionType
 …
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type
+                                param->attributes.splice( param->attributes.end(), decl->attributes ); // copy and reset attributes from declaration to parameter
+                                // Copy and reset attributes from declaration to parameter:
+                                splice( param->attributes, decl->attributes );
                         } // if
                 } // for

src/Parser/TypeData.h

-              r2ed94a9
+              rb110bcc
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:18:49 2022
 // Update Count     : 203
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Mar  1 10:44:00 2023
+// Update Count     : 206
 //
 #pragma once
 #include <iosfwd>                                                                               // for ostream
 #include <list>                                                                                 // for list
 #include <string>                                                                               // for string
+#include <iosfwd>                                   // for ostream
+#include <list>                                     // for list
+#include <string>                                   // for string
+#include "ParseNode.h"                                                                  // for DeclarationNode, DeclarationNode::Ag...
+#include "SynTree/LinkageSpec.h"                                                // for Spec
+#include "SynTree/Type.h"                                                               // for Type, ReferenceToType (ptr only)
+#include "SynTree/SynTree.h"                                                    // for Visitor Nodes
+#include "AST/Type.hpp"                             // for Type
+#include "DeclarationNode.h"                        // for DeclarationNode
 struct TypeData {
 …
         struct Aggregate_t {
                 AggregateDecl::Aggregate kind;
+                ast::AggregateDecl::Aggregate kind;
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;
 …
                 bool body;
                 bool anon;
                 bool tagged;
                 const std::string * parent = nullptr;
 …
         DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
         Type::Qualifiers qualifiers;
+        ast::CV::Qualifiers qualifiers;
         DeclarationNode * forall = nullptr;
 …
 };
 Type * typebuild( const TypeData * );
+ast::Type * typebuild( const TypeData * );
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel = true );
+Type::Qualifiers buildQualifiers( const TypeData * td );
+Type * buildBasicType( const TypeData * );
+PointerType * buildPointer( const TypeData * );
+ArrayType * buildArray( const TypeData * );
+ReferenceType * buildReference( const TypeData * );
+AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
+ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );
+ReferenceToType * buildAggInst( const TypeData * );
+TypeDecl * buildVariable( const TypeData * );
+EnumDecl * buildEnum( const TypeData *, std::list< Attribute * >, LinkageSpec::Spec );
+TypeInstType * buildSymbolicInst( const TypeData * );
+TupleType * buildTuple( const TypeData * );
+TypeofType * buildTypeof( const TypeData * );
+VTableType * buildVtable( const TypeData * );
+Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName,
+                                                 Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+FunctionType * buildFunction( const TypeData * );
+Declaration * addEnumBase( Declaration *, const TypeData * );
+ast::CV::Qualifiers buildQualifiers( const TypeData * td );
+ast::Type * buildBasicType( const TypeData * );
+ast::PointerType * buildPointer( const TypeData * );
+ast::ArrayType * buildArray( const TypeData * );
+ast::ReferenceType * buildReference( const TypeData * );
+ast::AggregateDecl * buildAggregate( const TypeData *, std::vector<ast::ptr<ast::Attribute>> );
+ast::BaseInstType * buildComAggInst( const TypeData *, std::vector<ast::ptr<ast::Attribute>> && attributes, ast::Linkage::Spec linkage );
+ast::BaseInstType * buildAggInst( const TypeData * );
+ast::TypeDecl * buildVariable( const TypeData * );
+ast::EnumDecl * buildEnum( const TypeData *, std::vector<ast::ptr<ast::Attribute>> &&, ast::Linkage::Spec );
+ast::TypeInstType * buildSymbolicInst( const TypeData * );
+ast::TupleType * buildTuple( const TypeData * );
+ast::TypeofType * buildTypeof( const TypeData * );
+ast::VTableType * buildVtable( const TypeData * );
+ast::Decl * buildDecl(
+        const TypeData *, const std::string &, ast::Storage::Classes, ast::Expr *,
+        ast::Function::Specs funcSpec, ast::Linkage::Spec, ast::Expr * asmName,
+        ast::Init * init = nullptr, std::vector<ast::ptr<ast::Attribute>> && attributes = std::vector<ast::ptr<ast::Attribute>>() );
+ast::FunctionType * buildFunctionType( const TypeData * );
+ast::Decl * addEnumBase( Declaration *, const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );

src/Parser/TypedefTable.cc

-              r2ed94a9
+              rb110bcc
 #include "TypedefTable.h"
+#include <cassert>                                                                              // for assert
+#include <iostream>
+#include <cassert>                                // for assert
+#include <string>                                 // for string
+#include <iostream>                               // for iostream
+#include "ExpressionNode.h"                       // for LabelNode
+#include "ParserTypes.h"                          // for Token
+#include "StatementNode.h"                        // for CondCtl, ForCtrl
+// This (generated) header must come late as it is missing includes.
+#include "parser.hh"              // for IDENTIFIER, TYPEDEFname, TYPEGENname
 using namespace std;
 #if 0
 #define debugPrint( code ) code
+static const char *kindName( int kind ) {
+        switch ( kind ) {
+        case IDENTIFIER: return "identifier";
+        case TYPEDIMname: return "typedim";
+        case TYPEDEFname: return "typedef";
+        case TYPEGENname: return "typegen";
+        default:
+                cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
+                abort();
+        } // switch
+} // kindName
 #else
 #define debugPrint( code )
 #endif
-using namespace std;                                                                    // string, iostream
-debugPrint(
-        static const char *kindName( int kind ) {
-                switch ( kind ) {
-                  case IDENTIFIER: return "identifier";
-                  case TYPEDIMname: return "typedim";
-                  case TYPEDEFname: return "typedef";
-                  case TYPEGENname: return "typegen";
-                  default:
-                        cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
-                        abort();
-                } // switch
-        } // kindName
-);
 TypedefTable::~TypedefTable() {
 …
                 typedefTable.addToEnclosingScope( name, kind, "MTD" );
         } // if
+} // TypedefTable::makeTypedef
+void TypedefTable::makeTypedef( const string & name ) {
+        return makeTypedef( name, TYPEDEFname );
 } // TypedefTable::makeTypedef

src/Parser/TypedefTable.h

-              r2ed94a9
+              rb110bcc
 #include "Common/ScopedMap.h"                                                   // for ScopedMap
-#include "ParserTypes.h"
-#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname
 class TypedefTable {
         struct Note { size_t level; bool forall; };
         typedef ScopedMap< std::string, int, Note > KindTable;
         KindTable kindTable;
+        KindTable kindTable;
         unsigned int level = 0;
   public:
 …
         bool existsCurr( const std::string & identifier ) const;
         int isKind( const std::string & identifier ) const;
+        void makeTypedef( const std::string & name, int kind = TYPEDEFname );
+        void makeTypedef( const std::string & name, int kind );
+        void makeTypedef( const std::string & name );
         void addToScope( const std::string & identifier, int kind, const char * );
         void addToEnclosingScope( const std::string & identifier, int kind, const char * );

src/Parser/lex.ll

-              r2ed94a9
+              rb110bcc
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Mon Jan 30 19:03:34 2023
  * Update Count     : 767
+ * Last Modified On : Sat Mar 25 08:09:03 2023
+ * Update Count     : 768
  */
 …
 // line-number directives) and C/C++ style comments, which are ignored.
 //**************************** Includes and Defines ****************************
+// *************************** Includes and Defines ****************************
 #ifdef __clang__
 …
 #include "config.h"                                                                             // configure info
+#include "DeclarationNode.h"                            // for DeclarationNode
+#include "ExpressionNode.h"                             // for LabelNode
+#include "InitializerNode.h"                            // for InitializerNode
 #include "ParseNode.h"
+#include "ParserTypes.h"                                // for Token
+#include "StatementNode.h"                              // for CondCtl, ForCtrl
 #include "TypedefTable.h"
+// This (generated) header must come late as it is missing includes.
+#include "parser.hh"                                    // generated info
 string * build_postfix_name( string * name );
 …
 __alignof               { KEYWORD_RETURN(ALIGNOF); }                    // GCC
 __alignof__             { KEYWORD_RETURN(ALIGNOF); }                    // GCC
+and                             { QKEYWORD_RETURN(WAND); }                              // CFA
 asm                             { KEYWORD_RETURN(ASM); }
 __asm                   { KEYWORD_RETURN(ASM); }                                // GCC

src/Parser/module.mk

-              r2ed94a9
+              rb110bcc
 SRC += \
        Parser/DeclarationNode.cc \
+       Parser/DeclarationNode.h \
        Parser/ExpressionNode.cc \
+       Parser/ExpressionNode.h \
        Parser/InitializerNode.cc \
+       Parser/InitializerNode.h \
        Parser/lex.ll \
        Parser/ParseNode.cc \
 …
        Parser/RunParser.hpp \
        Parser/StatementNode.cc \
+       Parser/StatementNode.h \
        Parser/TypeData.cc \
        Parser/TypeData.h \

src/Parser/parser.yy

-              r2ed94a9
+              rb110bcc
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  2 21:36:16 2023
 // Update Count     : 5865
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 14:02:00 2023
+// Update Count     : 6329
 //
 …
 #include <cstdio>
+#include <sstream>
 #include <stack>
 using namespace std;
+#include "SynTree/Declaration.h"
+#include "ParseNode.h"
+#include "SynTree/Type.h"                               // for Type
+#include "DeclarationNode.h"                            // for DeclarationNode, ...
+#include "ExpressionNode.h"                             // for ExpressionNode, ...
+#include "InitializerNode.h"                            // for InitializerNode, ...
+#include "ParserTypes.h"
+#include "StatementNode.h"                              // for build_...
 #include "TypedefTable.h"
 #include "TypeData.h"
-#include "SynTree/LinkageSpec.h"
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
 #include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Attribute.h"                                                  // for Attribute
 // lex uses __null in a boolean context, it's fine.
 …
 extern DeclarationNode * parseTree;
 extern LinkageSpec::Spec linkage;
+extern ast::Linkage::Spec linkage;
 extern TypedefTable typedefTable;
 stack<LinkageSpec::Spec> linkageStack;
+stack<ast::Linkage::Spec> linkageStack;
 bool appendStr( string & to, string & from ) {
 …
 } // fieldDecl
 #define NEW_ZERO new ExpressionNode( build_constantInteger( *new string( "0" ) ) )
 #define NEW_ONE  new ExpressionNode( build_constantInteger( *new string( "1" ) ) )
+#define NEW_ZERO new ExpressionNode( build_constantInteger( yylloc, *new string( "0" ) ) )
+#define NEW_ONE  new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) )
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
 #define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
 …
 #define MISSING_HIGH "Missing high value for down-to range so index is uninitialized."
+ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+static ForCtrl * makeForCtrl(
+                const CodeLocation & location,
+                DeclarationNode * init,
+                enum OperKinds compop,
+                ExpressionNode * comp,
+                ExpressionNode * inc ) {
+        // Wrap both comp/inc if they are non-null.
+        if ( comp ) comp = new ExpressionNode( build_binary_val( location,
+                compop,
+                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                comp ) );
+        if ( inc ) inc = new ExpressionNode( build_binary_val( location,
+                // choose += or -= for upto/downto
+                compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn,
+                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                inc ) );
+        // The StatementNode call frees init->name, it must happen later.
+        return new ForCtrl( new StatementNode( init ), comp, inc );
+}
+ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
                 SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
 …
                 SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." );
         } // if
+        return new ForCtrl( index->addInitializer( new InitializerNode( start ) ),
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index->name ) ) ), comp ) ) : nullptr,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index->name ) ) ), inc ) ) : nullptr );
+        DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) );
+        return makeForCtrl( location, initDecl, compop, comp, inc );
 } // forCtrl
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
                 type = new ExpressionNode( new CastExpr( maybeMoveBuild<Expression>(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
+        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
+                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicType::SignedInt ) ) );
         } // if
+//      type = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__for_control_index_constraints__" ) ) ), type ) );
+        return new ForCtrl(
+                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : nullptr,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : nullptr );
+        DeclarationNode * initDecl = distAttr(
+                DeclarationNode::newTypeof( type, true ),
+                DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) )
+        );
+        return makeForCtrl( location, initDecl, compop, comp, inc );
 } // forCtrl
 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
         } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
                 if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
                         return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
+                return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
+                if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
+                        return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
 …
 %union {
         Token tok;
+        ParseNode * pn;
+        ExpressionNode * en;
+        ExpressionNode * expr;
         DeclarationNode * decl;
         AggregateDecl::Aggregate aggKey;
         TypeDecl::Kind tclass;
         StatementNode * sn;
         WaitForStmt * wfs;
         Expression * constant;
+        ast::AggregateDecl::Aggregate aggKey;
+        ast::TypeDecl::Kind tclass;
+        StatementNode * stmt;
+        ClauseNode * clause;
+        ast::WaitForStmt * wfs;
         CondCtl * ifctl;
+        ForCtrl * fctl;
+        OperKinds compop;
+        LabelNode * label;
+        InitializerNode * in;
+        OperKinds op;
+        ForCtrl * forctl;
+        LabelNode * labels;
+        InitializerNode * init;
+        OperKinds oper;
         std::string * str;
         bool flag;
         EnumHiding hide;
         CatchStmt::Kind catch_kind;
         GenericExpr * genexpr;
+        bool is_volatile;
+        EnumHiding enum_hiding;
+        ast::ExceptionKind except_kind;
+        ast::GenericExpr * genexpr;
+}
 //************************* TERMINAL TOKENS ********************************
+// ************************ TERMINAL TOKENS ********************************
 // keywords
 …
 // names and constants: lexer differentiates between identifier and typedef names
 %token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDIMname             TYPEDEFname             TYPEGENname
 %token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
+%token<tok> IDENTIFIER          TYPEDIMname             TYPEDEFname             TYPEGENname
+%token<tok> TIMEOUT                     WAND    WOR                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
 %token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
 %token<tok> DIRECTIVE
 …
 %type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
+%type<expr> string_literal
 %type<str> string_literal_list
 %type<hide> hide_opt                                    visible_hide_opt
+%type<enum_hiding> hide_opt                                     visible_hide_opt
 // expressions
 %type<en> constant
 %type<en> tuple                                                 tuple_expression_list
 %type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
 %type<en> shift_expression                              relational_expression           equality_expression
 %type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
 %type<en> logical_AND_expression                logical_OR_expression
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
+%type<expr> constant
+%type<expr> tuple                                                       tuple_expression_list
+%type<oper> ptrref_operator                             unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
+%type<expr> primary_expression                  postfix_expression                      unary_expression
+%type<expr> cast_expression_list                        cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<expr> shift_expression                            relational_expression           equality_expression
+%type<expr> AND_expression                              exclusive_OR_expression         inclusive_OR_expression
+%type<expr> logical_AND_expression              logical_OR_expression
+%type<expr> conditional_expression              constant_expression                     assignment_expression           assignment_expression_opt
+%type<expr> comma_expression                            comma_expression_opt
+%type<expr> argument_expression_list_opt        argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> conditional_declaration
 %type<fctl> for_control_expression              for_control_expression_list
 %type<compop> upupeq updown updowneq downupdowneq
 %type<en> subrange
+%type<forctl> for_control_expression            for_control_expression_list
+%type<oper> upupeq updown updowneq downupdowneq
+%type<expr> subrange
 %type<decl> asm_name_opt
 %type<en> asm_operands_opt                              asm_operands_list                       asm_operand
 %type<label> label_list
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
+%type<expr> asm_operands_opt                            asm_operands_list                       asm_operand
+%type<labels> label_list
+%type<expr> asm_clobbers_list_opt
+%type<is_volatile> asm_volatile_opt
+%type<expr> handler_predicate_opt
 %type<genexpr> generic_association              generic_assoc_list
 // statements
+%type<sn> statement                                             labeled_statement                       compound_statement
+%type<sn> statement_decl                                statement_decl_list                     statement_list_nodecl
+%type<sn> selection_statement                   if_statement
+%type<sn> switch_clause_list_opt                switch_clause_list
+%type<en> case_value
+%type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
+%type<sn> iteration_statement                   jump_statement
+%type<sn> expression_statement                  asm_statement
+%type<sn> with_statement
+%type<en> with_clause_opt
+%type<sn> exception_statement                   handler_clause                          finally_clause
+%type<catch_kind> handler_key
+%type<sn> mutex_statement
+%type<en> when_clause                                   when_clause_opt                         waitfor                                         timeout
+%type<sn> waitfor_statement
+%type<wfs> waitfor_clause
+%type<stmt> statement                                           labeled_statement                       compound_statement
+%type<stmt> statement_decl                              statement_decl_list                     statement_list_nodecl
+%type<stmt> selection_statement                 if_statement
+%type<clause> switch_clause_list_opt            switch_clause_list
+%type<expr> case_value
+%type<clause> case_clause                               case_value_list                         case_label                                      case_label_list
+%type<stmt> iteration_statement                 jump_statement
+%type<stmt> expression_statement                        asm_statement
+%type<stmt> with_statement
+%type<expr> with_clause_opt
+%type<stmt> exception_statement
+%type<clause> handler_clause                    finally_clause
+%type<except_kind> handler_key
+%type<stmt> mutex_statement
+%type<expr> when_clause                                 when_clause_opt                         waitfor         waituntil               timeout
+%type<stmt> waitfor_statement                           waituntil_statement
+%type<wfs> wor_waitfor_clause                   waituntil_clause                        wand_waituntil_clause   wor_waituntil_clause
 // declarations
 …
 %type<decl> assertion assertion_list assertion_list_opt
 %type<en> bit_subrange_size_opt bit_subrange_size
+%type<expr> bit_subrange_size_opt bit_subrange_size
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
 …
 %type<decl> enumerator_list enum_type enum_type_nobody
 %type<in> enumerator_value_opt
+%type<init> enumerator_value_opt
 %type<decl> external_definition external_definition_list external_definition_list_opt
 …
 %type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list_opt field_abstract
 %type<en> field field_name_list field_name fraction_constants_opt
+%type<expr> field field_name_list field_name fraction_constants_opt
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
 …
 %type<decl> typedef_name typedef_declaration typedef_expression
+%type<decl> variable_type_redeclarator type_ptr type_array type_function
+%type<decl> variable_type_redeclarator variable_type_ptr variable_type_array variable_type_function
+%type<decl> general_function_declarator function_type_redeclarator function_type_array function_type_no_ptr function_type_ptr
 %type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
 …
 %type<decl> type_parameter type_parameter_list type_initializer_opt
 %type<en> type_parameters_opt type_list array_type_list
+%type<expr> type_parameters_opt type_list array_type_list
 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
 …
 // initializers
 %type<in>  initializer initializer_list_opt initializer_opt
+%type<init>  initializer initializer_list_opt initializer_opt
 // designators
 %type<en>  designator designator_list designation
+%type<expr>  designator designator_list designation
 …
 // Similar issues exit with the waitfor statement.
 // Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
 // associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
+// Order of these lines matters (low-to-high precedence). THEN is left associative over WAND/WOR/TIMEOUT/ELSE, WAND/WOR
+// is left associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
 %precedence THEN                // rule precedence for IF/WAITFOR statement
+%precedence ANDAND              // token precedence for start of WAND in WAITFOR statement
+%precedence WAND                // token precedence for start of WAND in WAITFOR statement
+%precedence OROR                // token precedence for start of WOR in WAITFOR statement
 %precedence WOR                 // token precedence for start of WOR in WAITFOR statement
 %precedence TIMEOUT             // token precedence for start of TIMEOUT in WAITFOR statement
 …
 constant:
                 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
         INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
         | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
+        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( yylloc, *$1 ) ); }
+        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( yylloc, *$1 ) ); }
+        ;
 quasi_keyword:                                                                                  // CFA
         TIMEOUT
+        | WAND
         | WOR
         | CATCH
 …
 string_literal:
         string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
+        string_literal_list                                                     { $$ = new ExpressionNode( build_constantStr( yylloc, *$1 ) ); }
+        ;
 …
 primary_expression:
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
         | quasi_keyword
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
         | TYPEDIMname                                                                           // CFA, generic length argument
                 // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
                 // { $$ = new ExpressionNode( build_varref( $1 ) ); }
                 { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
+                { $$ = new ExpressionNode( build_dimensionref( yylloc, $1 ) ); }
         | tuple
         | '(' comma_expression ')'
                 { $$ = $2; }
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
+                { $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( $2 ) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
                 { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_qualified_expr( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
 …
+                {
                         // add the missing control expression to the GenericExpr and return it
                         $5->control = maybeMoveBuild<Expression>( $3 );
+                        $5->control = maybeMoveBuild( $3 );
                         $$ = new ExpressionNode( $5 );
+                }
 …
+                {
                         // steal the association node from the singleton and delete the wrapper
+                        $1->associations.splice($1->associations.end(), $3->associations);
+                        assert( 1 == $3->associations.size() );
+                        $1->associations.push_back( $3->associations.front() );
                         delete $3;
                         $$ = $1;
 …
+                {
                         // create a GenericExpr wrapper with one association pair
                         $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>( $3 ) } } );
+                        $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuildType( $1 ), maybeMoveBuild( $3 ) } } );
+                }
         | DEFAULT ':' assignment_expression
                 { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>( $3 ) } } ); }
+                { $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuild( $3 ) } } ); }
+        ;
 …
                 // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
                 // Current: Commas in subscripts make tuples.
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
         | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
 …
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | constant '[' assignment_expression ']'                        // 3[a], 'a'[a], 3.5[a]
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | string_literal '[' assignment_expression ']'          // "abc"[3], 3["abc"]
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
+                {
                         Token fn;
                         fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
                         $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                        $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | postfix_expression '(' argument_expression_list_opt ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, $1, $3 ) ); }
         | VA_ARG '(' primary_expression ',' declaration_specifier_nobody abstract_parameter_declarator_opt ')'
                 // { SemanticError( yylloc, "va_arg is currently unimplemented." ); $$ = nullptr; }
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__builtin_va_arg") ) ),
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg") ) ),
                                                                                            (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | constant '`' identifier                                                       // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | string_literal '`' identifier                                         // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | postfix_expression '.' identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 ) ) ); }
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | postfix_expression '.' aggregate_control
                 { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $3, $1 ) ); }
         | postfix_expression ARROW identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
         | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, new InitializerNode( $5, true ) ) ); }
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
+                {
                         Token fn;
                         fn.str = new string( "^?{}" );                          // location undefined
                         $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                        $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                }
+        ;
 …
         '@'                                                                                                     // CFA, default parameter
                 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
                 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
+                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
         | assignment_expression
+        ;
 …
         field_name
         | FLOATING_DECIMALconstant field
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), maybeMoveBuild( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), build_tuple( yylloc, $3 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
         | field_name '.' '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | field_name ARROW field
                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
         | field_name ARROW '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+        ;
 field_name:
         INTEGERconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_constantInteger( yylloc, *$1 ), $2 ) ); }
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_field_name_FLOATINGconstant( yylloc, *$1 ), $2 ) ); }
         | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+                {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_varref( yylloc, $1 ), $2 ) );
+                }
+        ;
 …
         | fraction_constants_opt FLOATING_FRACTIONconstant
+                {
                         Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
                         $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
+                        ast::Expr * constant = build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 );
+                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( yylloc, $1, constant ) ) : new ExpressionNode( constant );
+                }
+        ;
 …
         | constant
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
+                { $$ = $1; }
         | EXTENSION cast_expression                                                     // GCC
                 { $$ = $2->set_extension( true ); }
 …
+                {
                         switch ( $1 ) {
                           case OperKinds::AddressOf:
                                 $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) );
+                        case OperKinds::AddressOf:
+                                $$ = new ExpressionNode( new ast::AddressExpr( maybeMoveBuild( $2 ) ) );
                                 break;
                           case OperKinds::PointTo:
                                 $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
+                        case OperKinds::PointTo:
+                                $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) );
                                 break;
                           case OperKinds::And:
                                 $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) ) );
+                        case OperKinds::And:
+                                $$ = new ExpressionNode( new ast::AddressExpr( new ast::AddressExpr( maybeMoveBuild( $2 ) ) ) );
                                 break;
                           default:
+                        default:
                                 assert( false );
+                        }
+                }
         | unary_operator cast_expression
                 { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) ); }
         | ICR unary_expression
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Incr, $2 ) ); }
         | DECR unary_expression
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | OFFSETOF '(' type_no_function ',' identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); }
         | TYPEID '(' type_no_function ')'
+                {
 …
         unary_expression
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
         | '(' aggregate_control '*' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
 …
                 { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+//              { $$ = new ast::ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+        ;
 …
         cast_expression
         | exponential_expression '\\' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Exp, $1, $3 ) ); }
+        ;
 …
         exponential_expression
         | multiplicative_expression '*' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mod, $1, $3 ) ); }
+        ;
 …
         multiplicative_expression
         | additive_expression '+' multiplicative_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Plus, $1, $3 ) ); }
         | additive_expression '-' multiplicative_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Minus, $1, $3 ) ); }
+        ;
 …
         additive_expression
         | shift_expression LS additive_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LShift, $1, $3 ) ); }
         | shift_expression RS additive_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::RShift, $1, $3 ) ); }
+        ;
 …
         shift_expression
         | relational_expression '<' shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LThan, $1, $3 ) ); }
         | relational_expression '>' shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GThan, $1, $3 ) ); }
         | relational_expression LE shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LEThan, $1, $3 ) ); }
         | relational_expression GE shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GEThan, $1, $3 ) ); }
+        ;
 …
         relational_expression
         | equality_expression EQ relational_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Eq, $1, $3 ) ); }
         | equality_expression NE relational_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Neq, $1, $3 ) ); }
+        ;
 …
         equality_expression
         | AND_expression '&' equality_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitAnd, $1, $3 ) ); }
+        ;
 …
         AND_expression
         | exclusive_OR_expression '^' AND_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Xor, $1, $3 ) ); }
+        ;
 …
         exclusive_OR_expression
         | inclusive_OR_expression '|' exclusive_OR_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitOr, $1, $3 ) ); }
+        ;
 …
         inclusive_OR_expression
         | logical_AND_expression ANDAND inclusive_OR_expression
                 { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
+                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::AndExpr ) ); }
+        ;
 …
         logical_AND_expression
         | logical_OR_expression OROR logical_AND_expression
                 { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
+                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::OrExpr ) ); }
+        ;
 …
         logical_OR_expression
         | logical_OR_expression '?' comma_expression ':' conditional_expression
                 { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
                 { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+        ;
 …
 //                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
 //                      } else {
                                 $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
+                                $$ = new ExpressionNode( build_binary_val( yylloc, $2, $1, $3 ) );
 //                      } // if
+                }
 …
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
         '[' ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $6 ) ) )); }
+        ;
 …
         assignment_expression
         | comma_expression ',' assignment_expression
                 { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::CommaExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+        ;
 …
         | mutex_statement
         | waitfor_statement
+        | waituntil_statement
         | exception_statement
         | enable_disable_statement
 …
         | asm_statement
         | DIRECTIVE
                 { $$ = new StatementNode( build_directive( $1 ) ); }
+                { $$ = new StatementNode( build_directive( yylloc, $1 ) ); }
+        ;
 …
                 // labels cannot be identifiers 0 or 1
         identifier_or_type_name ':' attribute_list_opt statement
                 { $$ = $4->add_label( $1, $3 ); }
+                { $$ = $4->add_label( yylloc, $1, $3 ); }
         | identifier_or_type_name ':' attribute_list_opt error // syntax error
+                {
 …
 compound_statement:
         '{' '}'
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
+                { $$ = new StatementNode( build_compound( yylloc, (StatementNode *)0 ) ); }
         | '{' push
           local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
                 { $$ = new StatementNode( build_compound( $4 ) ); }
+                { $$ = new StatementNode( build_compound( yylloc, $4 ) ); }
+        ;
 …
 expression_statement:
         comma_expression_opt ';'
+                { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
+                { $$ = new StatementNode( build_expr( yylloc, $1 ) ); }
+        ;
 …
                 { $$ = $2; }
         | SWITCH '(' comma_expression ')' case_clause
                 { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( yylloc, true, $3, $5 ) ); }
         | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+                {
                         StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
+                        StatementNode *sw = new StatementNode( build_switch( yylloc, true, $3, $8 ) );
                         // The semantics of the declaration list is changed to include associated initialization, which is performed
                         // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
 …
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
                         $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
         | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, syntax error
                 { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
                 { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); }
         | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+                {
                         StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
                         $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) );
+                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
         | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, syntax error
 …
         IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
+                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), nullptr ) ); }
         | IF '(' conditional_declaration ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
+                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), maybe_build_compound( yylloc, $7 ) ) ); }
+        ;
 …
         | declaration comma_expression                                          // semi-colon separated
                 { $$ = new CondCtl( $1, $2 ); }
+        ;
+        ;
 // CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case
 …
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
+        ;
 case_value_list:                                                                                // CFA
         case_value                                                                      { $$ = new StatementNode( build_case( $1 ) ); }
+        case_value                                                                      { $$ = new ClauseNode( build_case( yylloc, $1 ) ); }
                 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
         | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_last( new StatementNode( build_case( $3 ) ) ) ); }
+        | case_value_list ',' case_value                        { $$ = $1->set_last( new ClauseNode( build_case( yylloc, $3 ) ) ); }
+        ;
 …
         | CASE case_value_list error                                            // syntax error
                 { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; }
         | DEFAULT ':'                                                           { $$ = new StatementNode( build_default() ); }
+        | DEFAULT ':'                                                           { $$ = new ClauseNode( build_default( yylloc ) ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
         | DEFAULT error                                                                         //  syntax error
 …
 case_label_list:                                                                                // CFA
         case_label
         | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_last( $2 )); }
+        | case_label_list case_label                            { $$ = $1->set_last( $2 ); }
+        ;
 case_clause:                                                                                    // CFA
         case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( yylloc, $2 ) ); }
+        ;
 …
 switch_clause_list:                                                                             // CFA
         case_label_list statement_list_nodecl
                 { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
+                { $$ = $1->append_last_case( new StatementNode( build_compound( yylloc, $2 ) ) ); }
         | switch_clause_list case_label_list statement_list_nodecl
                 { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
+                { $$ = $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ); }
+        ;
 iteration_statement:
         WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); }
+                { $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) ); }
         | WHILE '(' ')' statement ELSE statement                        // CFA
+                {
                         $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) ); }
         | DO statement WHILE '(' ')' ELSE statement                     // CFA
+                {
                         $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ), $8 ) ); }
         | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+                { $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) ); }
         | FOR '(' ')' statement ELSE statement                          // CFA
+                {
                         $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
+                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+        ;
 …
                         if ( $1->condition ) {
                                 if ( $3->condition ) {
                                         $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
+                                        $1->condition->expr.reset( new ast::LogicalExpr( yylloc, $1->condition->expr.release(), $3->condition->expr.release(), ast::AndExpr ) );
                                 } // if
                         } else $1->condition = $3->condition;
                         if ( $1->change ) {
                                 if ( $3->change ) {
                                         $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
+                                        $1->change->expr.reset( new ast::CommaExpr( yylloc, $1->change->expr.release(), $3->change->expr.release() ) );
                                 } // if
                         } else $1->change = $3->change;
 …
 for_control_expression:
         ';' comma_expression_opt ';' comma_expression_opt
                 { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+                { $$ = new ForCtrl( nullptr, $2, $4 ); }
         | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( $1, $3, $5 ); }
+                {
+                        StatementNode * init = $1 ? new StatementNode( new ast::ExprStmt( yylloc, maybeMoveBuild( $1 ) ) ) : nullptr;
+                        $$ = new ForCtrl( init, $3, $5 );
+                }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
+                { $$ = new ForCtrl( new StatementNode( $1 ), $2, $4 ); }
         | '@' ';' comma_expression                                                      // CFA, empty loop-index
                 { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, nullptr ); }
+                { $$ = new ForCtrl( nullptr, $3, nullptr ); }
         | '@' ';' comma_expression ';' comma_expression         // CFA, empty loop-index
                 { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, $5 ); }
+                { $$ = new ForCtrl( nullptr, $3, $5 ); }
         | comma_expression                                                                      // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
         | downupdowneq comma_expression                                         // CFA, anonymous loop-index
                 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
         | comma_expression updowneq comma_expression            // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
         | '@' updowneq comma_expression                                         // CFA, anonymous loop-index
+                {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                }
         | comma_expression updowneq '@'                                         // CFA, anonymous loop-index
 …
+                }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
         | '@' updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
+                {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                }
         | comma_expression updowneq '@' '~' comma_expression // CFA, anonymous loop-index
 …
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
         | comma_expression ';' downupdowneq comma_expression // CFA
                 { $$ = forCtrl( $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
         | comma_expression ';' comma_expression updowneq comma_expression // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
         | comma_expression ';' '@' updowneq comma_expression // CFA
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                }
         | comma_expression ';' comma_expression updowneq '@' // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                }
         | comma_expression ';' '@' updowneq '@'                         // CFA, error
 …
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
         | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, $7 );
+                }
         | comma_expression ';' comma_expression updowneq '@' '~' comma_expression // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 );
+                }
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
         | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, nullptr );
+                }
         | comma_expression ';' comma_expression updowneq '@' '~' '@' // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr );
+                }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
 …
         | declaration comma_expression                                          // CFA
                 { $$ = forCtrl( $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
         | declaration downupdowneq comma_expression                     // CFA
                 { $$ = forCtrl( $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
         | declaration comma_expression updowneq comma_expression // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
         | declaration '@' updowneq comma_expression                     // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, NEW_ONE );
+                }
         | declaration comma_expression updowneq '@'                     // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, NEW_ONE );
+                }
         | declaration comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
         | declaration '@' updowneq comma_expression '~' comma_expression // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, $6 );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, $6 );
+                }
         | declaration comma_expression updowneq '@' '~' comma_expression // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, $6 );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, $6 );
+                }
         | declaration comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
         | declaration '@' updowneq comma_expression '~' '@' // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, nullptr );
+                }
         | declaration comma_expression updowneq '@' '~' '@'     // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr );
+                }
         | declaration '@' updowneq '@' '~' '@'                          // CFA, error
 …
                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
+                }
+        ;
+        ;
 downupdowneq:
 …
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
+        ;
+        ;
 updown:
 …
         | ErangeDown
                 { $$ = OperKinds::GThan; }
+        ;
+        ;
 updowneq:
 …
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
+        ;
+        ;
 jump_statement:
         GOTO identifier_or_type_name ';'
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Goto ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Goto ) ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
                 // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3);
 …
                 // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
         | fall_through_name ';'                                                         // CFA
                 { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThrough ) ); }
         | fall_through_name identifier_or_type_name ';'         // CFA
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::FallThrough ) ); }
         | fall_through_name DEFAULT ';'                                         // CFA
                 { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThroughDefault ) ); }
         | CONTINUE ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( build_branch( BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Continue ) ); }
         | CONTINUE identifier_or_type_name ';'                          // CFA, multi-level continue
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Continue ) ); }
         | BREAK ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Break ) ); }
         | BREAK identifier_or_type_name ';'                                     // CFA, multi-level exit
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Break ) ); }
         | RETURN comma_expression_opt ';'
                 { $$ = new StatementNode( build_return( $2 ) ); }
+                { $$ = new StatementNode( build_return( yylloc, $2 ) ); }
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
         | SUSPEND ';'
                 { $$ = new StatementNode( build_suspend( nullptr ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::None ) ); }
         | SUSPEND compound_statement
                 { $$ = new StatementNode( build_suspend( $2 ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $2, ast::SuspendStmt::None ) ); }
         | SUSPEND COROUTINE ';'
                 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Coroutine ) ); }
         | SUSPEND COROUTINE compound_statement
                 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Coroutine ) ); }
         | SUSPEND GENERATOR ';'
                 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Generator ) ); }
         | SUSPEND GENERATOR compound_statement
                 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
+                { $$ = new StatementNode( build_throw( yylloc, $2 ) ); }
         | THROWRESUME assignment_expression_opt ';'                     // handles reresume
                 { $$ = new StatementNode( build_resume( $2 ) ); }
+                { $$ = new StatementNode( build_resume( yylloc, $2 ) ); }
         | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
                 { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
 …
 with_statement:
         WITH '(' tuple_expression_list ')' statement
                 { $$ = new StatementNode( build_with( $3, $5 ) ); }
+        ;
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
+                { $$ = new StatementNode( build_with( yylloc, $3, $5 ) ); }
+        ;
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so possibly change syntax to "with mutex".
 mutex_statement:
+        MUTEX '(' argument_expression_list ')' statement
+                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        MUTEX '(' argument_expression_list_opt ')' statement
+                {
+                        if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; }
+                        $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) );
+                }
+        ;
 …
                 { $$ = nullptr; }
         | when_clause
+        ;
-waitfor:
-        WAITFOR '(' cast_expression ')'
-                { $$ = $3; }
-//      | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
-//              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
-        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
-                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
 …
 timeout:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+waitfor_clause:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+wor:
+        OROR
+        | WOR
+waitfor:
+        WAITFOR '(' cast_expression ')'
+                { $$ = $3; }
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
+                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
+wor_waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
+        | when_clause_opt timeout statement                                     %prec THEN
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt ELSE statement
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
+                // Called first: create header for WaitForStmt.
+                { $$ = build_waitfor( yylloc, new ast::WaitForStmt( yylloc ), $1, $2, maybe_build_compound( yylloc, $3 ) ); }
+        | wor_waitfor_clause wor when_clause_opt waitfor statement
+                { $$ = build_waitfor( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
+        | wor_waitfor_clause wor when_clause_opt ELSE statement
+                { $$ = build_waitfor_else( yylloc, $1, $3, maybe_build_compound( yylloc, $5 ) ); }
+        | wor_waitfor_clause wor when_clause_opt timeout statement      %prec THEN
+                { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | when_clause_opt timeout statement WOR ELSE statement // syntax error
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
                 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | when_clause_opt timeout statement WOR when_clause ELSE statement
                 { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
+                { $$ = build_waitfor_else( yylloc, build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ), $7, maybe_build_compound( yylloc, $9 ) ); }
+        ;
 waitfor_statement:
+        when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
+        wor_waitfor_clause                                                                      %prec THEN
+                { $$ = new StatementNode( $1 ); }
+        ;
+wand:
+        ANDAND
+        | WAND
+        ;
+waituntil:
+        WAITUNTIL '(' cast_expression ')'
+                { $$ = $3; }
+        ;
+waituntil_clause:
+        when_clause_opt waituntil statement
+                { printf( "waituntil_clause 1\n" ); $$ = nullptr; }
+        | '(' wor_waituntil_clause ')'
+                { printf( "waituntil_clause 2\n" ); $$ = nullptr; }
+        ;
+wand_waituntil_clause:
+        waituntil_clause                                                                        %prec THEN
+                { printf( "wand_waituntil_clause 1\n" ); $$ = nullptr; }
+        | waituntil_clause wand wand_waituntil_clause
+                { printf( "wand_waituntil_clause 2\n" ); $$ = nullptr; }
+        ;
+wor_waituntil_clause:
+        wand_waituntil_clause
+                { printf( "wor_waituntil_clause 1\n" ); $$ = nullptr; }
+        | wor_waituntil_clause wor wand_waituntil_clause
+                { printf( "wor_waituntil_clause 2\n" ); $$ = nullptr; }
+        | wor_waituntil_clause wor when_clause_opt ELSE statement
+                { printf( "wor_waituntil_clause 3\n" ); $$ = nullptr; }
+        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
+                { printf( "wor_waituntil_clause 4\n" ); $$ = nullptr; }
+        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
+                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
+                { printf( "wor_waituntil_clause 6\n" ); $$ = nullptr; }
+        ;
+waituntil_statement:
+        wor_waituntil_clause                                                            %prec THEN
+                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
+                { $$ = new StatementNode( build_compound( yylloc, nullptr ) ); }
+        ;
 exception_statement:
         TRY compound_statement handler_clause                                   %prec THEN
                 { $$ = new StatementNode( build_try( $2, $3, nullptr ) ); }
+        TRY compound_statement handler_clause                                   %prec THEN
+                { $$ = new StatementNode( build_try( yylloc, $2, $3, nullptr ) ); }
         | TRY compound_statement finally_clause
                 { $$ = new StatementNode( build_try( $2, nullptr, $3 ) ); }
+                { $$ = new StatementNode( build_try( yylloc, $2, nullptr, $3 ) ); }
         | TRY compound_statement handler_clause finally_clause
                 { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
+                { $$ = new StatementNode( build_try( yylloc, $2, $3, $4 ) ); }
+        ;
 handler_clause:
         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
                 { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
+                { $$ = new ClauseNode( build_catch( yylloc, $1, $4, $6, $8 ) ); }
         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
+                { $$ = $1->set_last( new ClauseNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); }
+        ;
 …
 handler_key:
         CATCH                                                                           { $$ = CatchStmt::Terminate; }
         | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
         | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
         | FIXUP                                                                         { $$ = CatchStmt::Resume; }
+        CATCH                                                                           { $$ = ast::Terminate; }
+        | RECOVER                                                                       { $$ = ast::Terminate; }
+        | CATCHRESUME                                                           { $$ = ast::Resume; }
+        | FIXUP                                                                         { $$ = ast::Resume; }
+        ;
 finally_clause:
         FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( $2 ) ); }
+        FINALLY compound_statement                                      { $$ = new ClauseNode( build_finally( yylloc, $2 ) ); }
+        ;
 …
 asm_statement:
         ASM asm_volatile_opt '(' string_literal ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, nullptr ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, nullptr ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
                 { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8, $10 ) ); }
         | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $5, nullptr, $8, $10, $12 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $5, nullptr, $8, $10, $12 ) ); }
+        ;
 …
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
                 { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AsmExpr( yylloc, "", maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
+                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild<Expression>( $6 ) ) ); }
+                {
+                        $$ = new ExpressionNode( new ast::AsmExpr( yylloc, *$2.str, maybeMoveBuild( $4 ), maybeMoveBuild( $6 ) ) );
+                        delete $2.str;
+                }
+        ;
 …
                 { $$ = nullptr; }                                                               // use default argument
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
+                { $$ = $1; }
         | asm_clobbers_list_opt ',' string_literal
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 ) ); }
+        ;
 …
         identifier
+                {
                         $$ = new LabelNode(); $$->labels.push_back( *$1 );
+                        $$ = new LabelNode(); $$->labels.emplace_back( yylloc, *$1 );
                         delete $1;                                                                      // allocated by lexer
+                }
         | label_list ',' identifier
+                {
                         $$ = $1; $1->labels.push_back( *$3 );
+                        $$ = $1; $1->labels.emplace_back( yylloc, *$3 );
                         delete $3;                                                                      // allocated by lexer
+                }
 …
+                {
                         // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
                 { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, maybeMoveBuild( $5 ) ); }
         | STATICASSERT '(' constant_expression ')' ';'          // CFA
                 { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( yylloc, *new string( "\"\"" ) ) ); }
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
 …
         TYPEDEF type_specifier declarator
+                {
-                        // if type_specifier is an anon aggregate => name
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
+                        $$ = $3->addType( $2 )->addTypedef();
+                        if ( $2->type->forall || ($2->type->kind == TypeData::Aggregate && $2->type->aggregate.params) ) {
+                                SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." ); $$ = nullptr;
+                        } else $$ = $3->addType( $2 )->addTypedef(); // watchout frees $2 and $3
+                }
         | typedef_declaration pop ',' push declarator
 …
+                }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
+                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
         | type_specifier TYPEDEF declarator
+                {
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
+                        $$ = $3->addType( $1 )->addTypedef();
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
         | type_specifier TYPEDEF type_qualifier_list declarator
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
+                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
+        ;
 …
         TYPEDEF identifier '=' assignment_expression
+                {
                         SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
         | typedef_expression pop ',' push identifier '=' assignment_expression
+                {
                         SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
+        ;
 …
         | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
+                {
+                        assert( $1->type );
+                        if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
+                                SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr;
+                        }
+                        // enums are never empty declarations because there must have at least one enumeration.
+                        if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
+                                SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
+                        }
+                }
+        ;
 …
                 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
                 // storage-class
         declarator asm_name_opt initializer_opt
+        variable_declarator asm_name_opt initializer_opt
                 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
+        | variable_type_redeclarator asm_name_opt initializer_opt
+                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
+        | general_function_declarator asm_name_opt
+                { $$ = $1->addAsmName( $2 )->addInitializer( nullptr ); }
+        | general_function_declarator asm_name_opt '=' VOID
+                { $$ = $1->addAsmName( $2 )->addInitializer( new InitializerNode( true ) ); }
         | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
                 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
+        ;
+general_function_declarator:
+        function_type_redeclarator
+        | function_declarator
+        ;
 …
         | sue_declaration_specifier invalid_types
+                {
+                        SemanticError( yylloc,
+                                                  ::toString( "Missing ';' after end of ",
+                                                                          $1->type->enumeration.name ? "enum" : AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                                                          " declaration" ) );
+                        SemanticError( yylloc, ::toString( "Missing ';' after end of ",
+                                $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                " declaration" ) );
                         $$ = nullptr;
+                }
 …
         basic_type_specifier
         | sue_type_specifier
+                {
-                        // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
-                        //   printf( "\tattr %s\n", attr->name.c_str() );
-                        // } // for
+                }
         | type_type_specifier
+        ;
 …
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
                 { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ), true ); }
         | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3, true ); }
 …
+                {
                         // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
+                {
                         // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
+                {
                         // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "aggregate_type1 %s\n", $3.str->c_str() );
-                        // if ( $2 )
-                        //      for ( Attribute * attr: reverseIterate( $2->attributes ) ) {
-                        //              printf( "copySpecifiers12 %s\n", attr->name.c_str() );
-                        //      } // for
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
-                        // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
-                        //      printf( "aggregate_type3 %s\n", attr->name.c_str() );
-                        // } // for
+                }
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 …
                         // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
                         // delete newFromTypeGen.
+                        $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+                        $3->type->symbolic.name = nullptr;
+                        $3->type->symbolic.actuals = nullptr;
+                        delete $3;
+                        if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) {
+                                $$ = $3->addQualifiers( $2 );
+                        } else {
+                                $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+                                $3->type->symbolic.name = nullptr;                      // copied to $$
+                                $3->type->symbolic.actuals = nullptr;
+                                delete $3;
+                        }
+                }
+        ;
 …
 aggregate_data:
         STRUCT vtable_opt
                 { $$ = AggregateDecl::Struct; }
+                { $$ = ast::AggregateDecl::Struct; }
         | UNION
                 { $$ = AggregateDecl::Union; }
+                { $$ = ast::AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
                 { $$ = AggregateDecl::Exception; }
           //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                { $$ = ast::AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }
+        ;
 aggregate_control:                                                                              // CFA
         MONITOR
                 { $$ = AggregateDecl::Monitor; }
+                { $$ = ast::AggregateDecl::Monitor; }
         | MUTEX STRUCT
                 { $$ = AggregateDecl::Monitor; }
+                { $$ = ast::AggregateDecl::Monitor; }
         | GENERATOR
                 { $$ = AggregateDecl::Generator; }
+                { $$ = ast::AggregateDecl::Generator; }
         | MUTEX GENERATOR
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor generator is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
         | COROUTINE
                 { $$ = AggregateDecl::Coroutine; }
+                { $$ = ast::AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor coroutine is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
         | THREAD
                 { $$ = AggregateDecl::Thread; }
+                { $$ = ast::AggregateDecl::Thread; }
         | MUTEX THREAD
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor thread is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
+        ;
 …
                         $$ = fieldDecl( $1, $2 );
                         // printf( "type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
         | STATIC type_specifier field_declaring_list_opt ';' // CFA
                 { SemanticError( yylloc, "STATIC aggregate field qualifier currently unimplemented." ); $$ = nullptr; }
+                { SemanticError( yylloc, "STATIC aggregate field qualifier currently unimplemented." ); $$ = nullptr; }
         | INLINE type_specifier field_abstract_list_opt ';'     // CFA
+                {
 …
+                }
         | INLINE aggregate_control ';'                                          // CFA
                 { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
+                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
         | typedef_declaration ';'                                                       // CFA
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
 …
                 { $$ = $1->addBitfield( $2 ); }
         | variable_type_redeclarator bit_subrange_size_opt
+                // A semantic check is required to ensure bit_subrange only appears on integral types.
+                { $$ = $1->addBitfield( $2 ); }
+        | function_type_redeclarator bit_subrange_size_opt
                 // A semantic check is required to ensure bit_subrange only appears on integral types.
                 { $$ = $1->addBitfield( $2 ); }
 …
                 { $$ = DeclarationNode::newEnum( $3->name, $6, true, false, nullptr, $4 )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() )
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 …
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
+                {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6 );
+                }
 …
 type_no_function:                                                                               // sizeof, alignof, cast (constructor)
         cfa_abstract_declarator_tuple                                           // CFA
         | type_specifier
+        | type_specifier                                                                        // cannot be type_specifier_nobody, e.g., (struct S {}){} is a thing
         | type_specifier abstract_declarator
                 { $$ = $2->addType( $1 ); }
 …
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier_at ':'                                                                     // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+        ;
 …
 designator:
         '.' identifier_at                                                                       // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
                 // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
 …
                 { $$ = $3; }
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $3 ), maybeMoveBuild<Expression>( $5 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
         | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
 …
+                {
                         typedefTable.addToScope( *$2, TYPEDEFname, "9" );
                         if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
                         if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
                         if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                        if ( $1 == ast::TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
+                        if ( $1 == ast::TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
+                        if ( $1 == ast::TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                }
           type_initializer_opt assertion_list_opt
 …
+                {
                         typedefTable.addToScope( *$2, TYPEDIMname, "9" );
                         $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
+                        $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dimension, $2 );
+                }
         // | type_specifier identifier_parameter_declarator
         | assertion_list
                 { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+                { $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+        ;
 new_type_class:                                                                                 // CFA
         // empty
                 { $$ = TypeDecl::Otype; }
+                { $$ = ast::TypeDecl::Otype; }
         | '&'
                 { $$ = TypeDecl::Dtype; }
+                { $$ = ast::TypeDecl::Dtype; }
         | '*'
                 { $$ = TypeDecl::DStype; }                                              // dtype + sized
+                { $$ = ast::TypeDecl::DStype; }                                         // dtype + sized
         // | '(' '*' ')'
         //      { $$ = TypeDecl::Ftype; }
+        //      { $$ = ast::TypeDecl::Ftype; }
         | ELLIPSIS
                 { $$ = TypeDecl::Ttype; }
+                { $$ = ast::TypeDecl::Ttype; }
+        ;
 type_class:                                                                                             // CFA
         OTYPE
                 { $$ = TypeDecl::Otype; }
+                { $$ = ast::TypeDecl::Otype; }
         | DTYPE
                 { $$ = TypeDecl::Dtype; }
+                { $$ = ast::TypeDecl::Dtype; }
         | FTYPE
                 { $$ = TypeDecl::Ftype; }
+                { $$ = ast::TypeDecl::Ftype; }
         | TTYPE
                 { $$ = TypeDecl::Ttype; }
+                { $$ = ast::TypeDecl::Ttype; }
+        ;
 …
 type_list:                                                                                              // CFA
         type
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression
         | type_list ',' type
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
         | type_list ',' assignment_expression
                 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
 …
         TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
+                {
                         SemanticWarning( yylloc, Warning::DeprecTraitSyntax, "" );
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
                         $$ = DeclarationNode::newTrait( $2, $4, nullptr );
+                }
 …
         | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
+                {
                         SemanticWarning( yylloc, Warning::DeprecTraitSyntax, "" );
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
                         $$ = DeclarationNode::newTrait( $2, $4, $8 );
+                }
 …
 external_definition:
         DIRECTIVE
                 { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( yylloc, $1 ) ) ); }
         | declaration
+                {
+                        // Variable declarations of anonymous types requires creating a unique type-name across multiple translation
+                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
+                        // disallowed at the moment.
+                        if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
+                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
+                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
+                                } else if ( $1->type->aggInst.aggregate->aggregate.anon ) { // handles struct or union
+                                        SemanticError( yylloc, "extern anonymous struct/union is currently unimplemented." ); $$ = nullptr;
+                                }
+                        }
+                }
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
 …
+                }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
                 { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, nullptr ) ) ); }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( yylloc, false, $3, nullptr ) ) ); }
         | EXTERN STRINGliteral
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                }
           up external_definition down
 …
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                }
           '{' up external_definition_list_opt down '}'
 …
         | type_qualifier_list
+                {
                         if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type->forall ) forall = true;          // remember generic type
+                }
 …
+                {
                         distQual( $5, $1 );
                         forall = false;
+                        forall = false;
                         $$ = $5;
+                }
         | declaration_qualifier_list
+                {
                         if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
+                }
 …
+                {
                         distQual( $5, $1 );
                         forall = false;
+                        forall = false;
                         $$ = $5;
+                }
         | declaration_qualifier_list type_qualifier_list
+                {
                         if ( ($1->type && $1->type->qualifiers.val) || ($2->type && $2->type->qualifiers.val) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
+                }
 …
+                {
                         distQual( $6, $1->addQualifiers( $2 ) );
                         forall = false;
+                        forall = false;
                         $$ = $6;
+                }
 …
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
+                }
         | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
+        | declaration_specifier function_type_redeclarator with_clause_opt compound_statement
+                {
                         rebindForall( $1, $2 );
 …
         | variable_type_redeclarator
         | function_declarator
+        | function_type_redeclarator
+        ;
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+        ;
 …
+                {
                         DeclarationNode * name = new DeclarationNode();
                         name->asmName = $3;
+                        name->asmName = maybeMoveBuild( $3 );
                         $$ = name->addQualifiers( $5 );
+                }
 …
         | '(' attribute_list variable_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
 …
+        ;
 // This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
+// This pattern parses a declaration for a variable that redefines a type name, e.g.:
 //
 //              typedef int foo;
 …
 //                 int foo; // redefine typedef name in new scope
 //              }
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
 paren_type:
 …
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | type_ptr
         | type_array attribute_list_opt
+        | variable_type_ptr
+        | variable_type_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | type_function attribute_list_opt
+        | variable_type_function attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        ;
 type_ptr:
+variable_type_ptr:
         ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
+        | '(' variable_type_ptr ')' attribute_list_opt          // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
+        | '(' attribute_list variable_type_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
 type_array:
+variable_type_array:
         paren_type array_dimension
                 { $$ = $1->addArray( $2 ); }
         | '(' type_ptr ')' array_dimension
+        | '(' variable_type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list type_ptr ')' array_dimension
+        | '(' attribute_list variable_type_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
+        | '(' variable_type_array ')' multi_array_dimension     // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
+        | '(' attribute_list variable_type_array ')' multi_array_dimension // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')'                                                            // redundant parenthesis
+        | '(' variable_type_array ')'                                           // redundant parenthesis
                 { $$ = $2; }
         | '(' attribute_list type_array ')'                                     // redundant parenthesis
+        | '(' attribute_list variable_type_array ')'            // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
+type_function:
+variable_type_function:
+        '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        | '(' variable_type_function ')'                                        // redundant parenthesis
+                { $$ = $2; }
+        | '(' attribute_list variable_type_function ')'         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
+// This pattern parses a declaration for a function prototype that redefines a type name.  It precludes declaring an
+// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
+// arrays and functions.
+function_type_redeclarator:
+        function_type_no_ptr attribute_list_opt
+                { $$ = $1->addQualifiers( $2 ); }
+        | function_type_ptr
+        | function_type_array attribute_list_opt
+                { $$ = $1->addQualifiers( $2 ); }
+        ;
+function_type_no_ptr:
         paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
         | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+        | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
         | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+        | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' type_function ')'                                                         // redundant parenthesis
+        | '(' function_type_no_ptr ')'                                          // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
+        | '(' attribute_list function_type_no_ptr ')'           // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
+function_type_ptr:
+        ptrref_operator function_type_redeclarator
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+        | ptrref_operator type_qualifier_list function_type_redeclarator
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
+        | '(' function_type_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list function_type_ptr ')' attribute_list_opt
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
+function_type_array:
+        '(' function_type_ptr ')' array_dimension
+                { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_type_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' function_type_array ')' multi_array_dimension     // redundant parenthesis
+                { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_type_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' function_type_array ')'                                           // redundant parenthesis
+                { $$ = $2; }
+        | '(' attribute_list function_type_array ')'            // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
 array_type_list:
         basic_type_name
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | type_name
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression upupeq assignment_expression
         | array_type_list ',' basic_type_name
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' type_name
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+        | array_type_list ',' type_name
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' assignment_expression upupeq assignment_expression
+        ;
 …
         | ErangeUpEq
                 { $$ = OperKinds::LEThan; }
+        ;
+        ;
 multi_array_dimension:

src/Parser/parserutility.cc

-              r2ed94a9
+              rb110bcc
 // Created On       : Sat May 16 15:30:39 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:12:00 2017
 // Update Count     : 8
+// Last Modified On : Wed Mar  1 10:42:00 2023
+// Update Count     : 9
 //
 …
 #include <string>                // for string
+#include "SynTree/Constant.h"    // for Constant
+#include "SynTree/Expression.h"  // for UntypedExpr, CastExpr, ConstantExpr
+#include "SynTree/Type.h"        // for BasicType, ZeroType, BasicType::Kind...
+#include "AST/Expr.hpp"          // for UntypedExpr, CastExpr, ConstantExpr
+#include "AST/Type.hpp"          // for BasicType, ZeroType, BasicType::Kind...
 // rewrite
 …
 //    if ( (int)(x != 0) ) ...
+Expression *notZeroExpr( Expression *orig ) {
+        if( !orig ) return nullptr;
+        UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
+        comparison->get_args().push_back( orig );
+        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( noQualifiers ), "0", (unsigned long long int)0 ) ) );
+        return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+ast::Expr * notZeroExpr( ast::Expr * orig ) {
+        return ( !orig ) ? nullptr : new ast::CastExpr( orig->location,
+                ast::UntypedExpr::createCall( orig->location,
+                        "?!=?",
+                        {
+                                orig,
+                                new ast::ConstantExpr( orig->location,
+                                        new ast::ZeroType(),
+                                        "0",
+                                        std::optional<unsigned long long>( 0 )
+                                ),
+                        }
+                ),
+                new ast::BasicType( ast::BasicType::SignedInt )
+        );
+}

src/Parser/parserutility.h

-              r2ed94a9
+              rb110bcc
 // file "LICENCE" distributed with Cforall.
 //
 // parserutility.h --
+// parserutility.h -- Collected utilities for the parser.
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:58 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 14:03:00 2023
+// Update Count     : 7
 //
 #pragma once
+class Expression;
+#include "AST/Copy.hpp"            // for shallowCopy
+namespace ast {
+        class Expr;
+}
+Expression *notZeroExpr( Expression *orig );
+ast::Expr * notZeroExpr( ast::Expr *orig );
+template< typename T >
+static inline auto maybeBuild( T * orig ) -> decltype(orig->build()) {
+        return (orig) ? orig->build() : nullptr;
+}
+template< typename T >
+static inline auto maybeMoveBuild( T * orig ) -> decltype(orig->build()) {
+        auto ret = maybeBuild<T>(orig);
+        delete orig;
+        return ret;
+}
+template<typename node_t>
+node_t * maybeCopy( node_t const * node ) {
+        return node ? ast::shallowCopy( node ) : nullptr;
+}
 // Local Variables: //

src/ResolvExpr/Candidate.cpp

-              r2ed94a9
+              rb110bcc
 #include <iostream>
+#include <sstream>
 #include "AST/Print.hpp"
 …
         sorted.reserve(cands.size());
         for(const auto & c : cands) {
                 std::stringstream ss;
+                std::ostringstream ss;
                 print( ss, *c, indent );
                 sorted.push_back(ss.str());

src/ResolvExpr/CandidateFinder.cpp

-              r2ed94a9
+              rb110bcc
 namespace ResolvExpr {
+/// Unique identifier for matching expression resolutions to their requesting expression
+UniqueId globalResnSlot = 0;
+namespace {
+        /// First index is which argument, second is which alternative, third is which exploded element
+        using ExplodedArgs_new = std::deque< std::vector< ExplodedArg > >;
+        /// Returns a list of alternatives with the minimum cost in the given list
+        CandidateList findMinCost( const CandidateList & candidates ) {
+                CandidateList out;
+                Cost minCost = Cost::infinity;
+                for ( const CandidateRef & r : candidates ) {
+                        if ( r->cost < minCost ) {
+                                minCost = r->cost;
+                                out.clear();
+                                out.emplace_back( r );
+                        } else if ( r->cost == minCost ) {
+                                out.emplace_back( r );
+                        }
+                }
+                return out;
+        }
+        /// Computes conversion cost for a given expression to a given type
+        const ast::Expr * computeExpressionConversionCost(
+                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
+        ) {
+                Cost convCost = computeConversionCost(
+                                arg->result, paramType, arg->get_lvalue(), symtab, env );
+                outCost += convCost;
+                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires
+                // conversion. Ignore poly cost for now, since this requires resolution of the cast to
+                // infer parameters and this does not currently work for the reason stated below
+                Cost tmpCost = convCost;
+                tmpCost.incPoly( -tmpCost.get_polyCost() );
+                if ( tmpCost != Cost::zero ) {
+                        ast::ptr< ast::Type > newType = paramType;
+                        env.apply( newType );
+                        return new ast::CastExpr{ arg, newType };
+                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not
+                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent,
+                        // once this is fixed it should be possible to resolve the cast.
+                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable,
+                        // but it shouldn't be because this makes the conversion from DT* to DT* since
+                        // commontype(zero_t, DT*) is DT*, rather than nothing
+                        // CandidateFinder finder{ symtab, env };
+                        // finder.find( arg, ResolvMode::withAdjustment() );
+                        // assertf( finder.candidates.size() > 0,
+                        //      "Somehow castable expression failed to find alternatives." );
+                        // assertf( finder.candidates.size() == 1,
+                        //      "Somehow got multiple alternatives for known cast expression." );
+                        // return finder.candidates.front()->expr;
+                }
+                return arg;
+        }
+        /// Computes conversion cost for a given candidate
+        Cost computeApplicationConversionCost(
+                CandidateRef cand, const ast::SymbolTable & symtab
+        ) {
+                auto appExpr = cand->expr.strict_as< ast::ApplicationExpr >();
+                auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
+                auto function = pointer->base.strict_as< ast::FunctionType >();
+                Cost convCost = Cost::zero;
+                const auto & params = function->params;
+                auto param = params.begin();
+                auto & args = appExpr->args;
+                for ( unsigned i = 0; i < args.size(); ++i ) {
+                        const ast::Type * argType = args[i]->result;
+                        PRINT(
+                                std::cerr << "arg expression:" << std::endl;
+                                ast::print( std::cerr, args[i], 2 );
+                                std::cerr << "--- results are" << std::endl;
+                                ast::print( std::cerr, argType, 2 );
+                        )
+                        if ( param == params.end() ) {
+                                if ( function->isVarArgs ) {
+                                        convCost.incUnsafe();
+                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: "
+                                                << convCost << std::endl; ; )
+                                        // convert reference-typed expressions into value-typed expressions
+                                        cand->expr = ast::mutate_field_index(
+                                                appExpr, &ast::ApplicationExpr::args, i,
+                                                referenceToRvalueConversion( args[i], convCost ) );
+                                        continue;
+                                } else return Cost::infinity;
+                        }
+                        if ( auto def = args[i].as< ast::DefaultArgExpr >() ) {
+                                // Default arguments should be free - don't include conversion cost.
+                                // Unwrap them here because they are not relevant to the rest of the system
+                                cand->expr = ast::mutate_field_index(
+                                        appExpr, &ast::ApplicationExpr::args, i, def->expr );
+                                ++param;
+                                continue;
+                        }
+                        // mark conversion cost and also specialization cost of param type
+                        // const ast::Type * paramType = (*param)->get_type();
+                        cand->expr = ast::mutate_field_index(
+                                appExpr, &ast::ApplicationExpr::args, i,
+                                computeExpressionConversionCost(
+                                        args[i], *param, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( *param ) );
+                        ++param;  // can't be in for-loop update because of the continue
+                }
+                if ( param != params.end() ) return Cost::infinity;
+                // specialization cost of return types can't be accounted for directly, it disables
+                // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
+                //
+                //   forall(otype OS) {
+                //     void ?|?(OS&, int);  // with newline
+                //     OS&  ?|?(OS&, int);  // no newline, always chosen due to more specialization
+                //   }
+                // mark type variable and specialization cost of forall clause
+                convCost.incVar( function->forall.size() );
+                convCost.decSpec( function->assertions.size() );
+                return convCost;
+        }
+        void makeUnifiableVars(
+                const ast::FunctionType * type, ast::OpenVarSet & unifiableVars,
+                ast::AssertionSet & need
+        ) {
+                for ( auto & tyvar : type->forall ) {
+                        unifiableVars[ *tyvar ] = ast::TypeData{ tyvar->base };
+                }
+                for ( auto & assn : type->assertions ) {
+                        need[ assn ].isUsed = true;
+                }
+        }
+        /// Gets a default value from an initializer, nullptr if not present
+        const ast::ConstantExpr * getDefaultValue( const ast::Init * init ) {
+                if ( auto si = dynamic_cast< const ast::SingleInit * >( init ) ) {
+                        if ( auto ce = si->value.as< ast::CastExpr >() ) {
+                                return ce->arg.as< ast::ConstantExpr >();
+                        } else {
+                                return si->value.as< ast::ConstantExpr >();
+                        }
+                }
+                return nullptr;
+        }
+        /// State to iteratively build a match of parameter expressions to arguments
+        struct ArgPack {
+                std::size_t parent;          ///< Index of parent pack
+                ast::ptr< ast::Expr > expr;  ///< The argument stored here
+                Cost cost;                   ///< The cost of this argument
+                ast::TypeEnvironment env;    ///< Environment for this pack
+                ast::AssertionSet need;      ///< Assertions outstanding for this pack
+                ast::AssertionSet have;      ///< Assertions found for this pack
+                ast::OpenVarSet open;        ///< Open variables for this pack
+                unsigned nextArg;            ///< Index of next argument in arguments list
+                unsigned tupleStart;         ///< Number of tuples that start at this index
+                unsigned nextExpl;           ///< Index of next exploded element
+                unsigned explAlt;            ///< Index of alternative for nextExpl > 0
+                ArgPack()
+                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ),
+                  tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
+                ArgPack(
+                        const ast::TypeEnvironment & env, const ast::AssertionSet & need,
+                        const ast::AssertionSet & have, const ast::OpenVarSet & open )
+                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ),
+                  open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
+                ArgPack(
+                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env,
+                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open,
+                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
+                        unsigned nextExpl = 0, unsigned explAlt = 0 )
+                : parent(parent), expr( expr ), cost( cost ), env( std::move( env ) ), need( std::move( need ) ),
+                  have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
+                  nextExpl( nextExpl ), explAlt( explAlt ) {}
+                ArgPack(
+                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
+                        ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added )
+                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( std::move( env ) ),
+                  need( std::move( need ) ), have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ),
+                  tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {}
+                /// true if this pack is in the middle of an exploded argument
+                bool hasExpl() const { return nextExpl > 0; }
+                /// Gets the list of exploded candidates for this pack
+                const ExplodedArg & getExpl( const ExplodedArgs_new & args ) const {
+                        return args[ nextArg-1 ][ explAlt ];
+                }
+                /// Ends a tuple expression, consolidating the appropriate args
+                void endTuple( const std::vector< ArgPack > & packs ) {
+                        // add all expressions in tuple to list, summing cost
+                        std::deque< const ast::Expr * > exprs;
+                        const ArgPack * pack = this;
+                        if ( expr ) { exprs.emplace_front( expr ); }
+                        while ( pack->tupleStart == 0 ) {
+                                pack = &packs[pack->parent];
+                                exprs.emplace_front( pack->expr );
+                                cost += pack->cost;
+                        }
+                        // reset pack to appropriate tuple
+                        std::vector< ast::ptr< ast::Expr > > exprv( exprs.begin(), exprs.end() );
+                        expr = new ast::TupleExpr{ expr->location, std::move( exprv ) };
+                        tupleStart = pack->tupleStart - 1;
+                        parent = pack->parent;
+                }
+        };
+        /// Instantiates an argument to match a parameter, returns false if no matching results left
+        bool instantiateArgument(
+                const CodeLocation & location,
+                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
+                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
+                unsigned nTuples = 0
+        ) {
+                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( paramType ) ) {
+                        // paramType is a TupleType -- group args into a TupleExpr
+                        ++nTuples;
+                        for ( const ast::Type * type : *tupleType ) {
+                                // xxx - dropping initializer changes behaviour from previous, but seems correct
+                                // ^^^ need to handle the case where a tuple has a default argument
+                                if ( ! instantiateArgument( location,
+                                        type, nullptr, args, results, genStart, symtab, nTuples ) ) return false;
+                                nTuples = 0;
+                        }
+                        // re-constitute tuples for final generation
+                        for ( auto i = genStart; i < results.size(); ++i ) {
+                                results[i].endTuple( results );
+                        }
+                        return true;
+                } else if ( const ast::TypeInstType * ttype = Tuples::isTtype( paramType ) ) {
+                        // paramType is a ttype, consumes all remaining arguments
+                        // completed tuples; will be spliced to end of results to finish
+                        std::vector< ArgPack > finalResults{};
+                        // iterate until all results completed
+                        std::size_t genEnd;
+                        ++nTuples;
+                        do {
+                                genEnd = results.size();
+                                // add another argument to results
+                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
+                                        unsigned nextArg = results[i].nextArg;
+                                        // use next element of exploded tuple if present
+                                        if ( results[i].hasExpl() ) {
+                                                const ExplodedArg & expl = results[i].getExpl( args );
+                                                unsigned nextExpl = results[i].nextExpl + 1;
+                                                if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
+                                                results.emplace_back(
+                                                        i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
+                                                        copy( results[i].need ), copy( results[i].have ),
+                                                        copy( results[i].open ), nextArg, nTuples, Cost::zero, nextExpl,
+                                                        results[i].explAlt );
+                                                continue;
+                                        }
+                                        // finish result when out of arguments
+                                        if ( nextArg >= args.size() ) {
+                                                ArgPack newResult{
+                                                        results[i].env, results[i].need, results[i].have, results[i].open };
+                                                newResult.nextArg = nextArg;
+                                                const ast::Type * argType = nullptr;
+                                                if ( nTuples > 0 || ! results[i].expr ) {
+                                                        // first iteration or no expression to clone,
+                                                        // push empty tuple expression
+                                                        newResult.parent = i;
+                                                        newResult.expr = new ast::TupleExpr( location, {} );
+                                                        argType = newResult.expr->result;
+                                                } else {
+                                                        // clone result to collect tuple
+                                                        newResult.parent = results[i].parent;
+                                                        newResult.cost = results[i].cost;
+                                                        newResult.tupleStart = results[i].tupleStart;
+                                                        newResult.expr = results[i].expr;
+                                                        argType = newResult.expr->result;
+                                                        if ( results[i].tupleStart > 0 && Tuples::isTtype( argType ) ) {
+                                                                // the case where a ttype value is passed directly is special,
+                                                                // e.g. for argument forwarding purposes
+                                                                // xxx - what if passing multiple arguments, last of which is
+                                                                //       ttype?
+                                                                // xxx - what would happen if unify was changed so that unifying
+                                                                //       tuple
+                                                                // types flattened both before unifying lists? then pass in
+                                                                // TupleType (ttype) below.
+                                                                --newResult.tupleStart;
+                                                        } else {
+                                                                // collapse leftover arguments into tuple
+                                                                newResult.endTuple( results );
+                                                                argType = newResult.expr->result;
+                                                        }
+                                                }
+                                                // check unification for ttype before adding to final
+                                                if (
+                                                        unify(
+                                                                ttype, argType, newResult.env, newResult.need, newResult.have,
+                                                                newResult.open, symtab )
+                                                ) {
+                                                        finalResults.emplace_back( std::move( newResult ) );
+                                                }
+                                                continue;
+                                        }
+                                        // add each possible next argument
+                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
+                                                const ExplodedArg & expl = args[nextArg][j];
+                                                // fresh copies of parent parameters for this iteration
+                                                ast::TypeEnvironment env = results[i].env;
+                                                ast::OpenVarSet open = results[i].open;
+                                                env.addActual( expl.env, open );
+                                                // skip empty tuple arguments by (nearly) cloning parent into next gen
+                                                if ( expl.exprs.empty() ) {
+                                                        results.emplace_back(
+                                                                results[i], std::move( env ), copy( results[i].need ),
+                                                                copy( results[i].have ), std::move( open ), nextArg + 1, expl.cost );
+                                                        continue;
+                                                }
+                                                // add new result
+                                                results.emplace_back(
+                                                        i, expl.exprs.front(), std::move( env ), copy( results[i].need ),
+                                                        copy( results[i].have ), std::move( open ), nextArg + 1, nTuples,
+                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                        }
+                                }
+                                // reset for next round
+                                genStart = genEnd;
+                                nTuples = 0;
+                        } while ( genEnd != results.size() );
+                        // splice final results onto results
+                        for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
+                                results.emplace_back( std::move( finalResults[i] ) );
+                        }
+                        return ! finalResults.empty();
+                }
+                // iterate each current subresult
+                std::size_t genEnd = results.size();
+                for ( std::size_t i = genStart; i < genEnd; ++i ) {
+                        unsigned nextArg = results[i].nextArg;
+                        // use remainder of exploded tuple if present
+                        if ( results[i].hasExpl() ) {
+                                const ExplodedArg & expl = results[i].getExpl( args );
+                                const ast::Expr * expr = expl.exprs[ results[i].nextExpl ];
+                                ast::TypeEnvironment env = results[i].env;
+                                ast::AssertionSet need = results[i].need, have = results[i].have;
+                                ast::OpenVarSet open = results[i].open;
+                                const ast::Type * argType = expr->result;
+                                PRINT(
+                                        std::cerr << "param type is ";
+                                        ast::print( std::cerr, paramType );
+                                        std::cerr << std::endl << "arg type is ";
+                                        ast::print( std::cerr, argType );
+                                        std::cerr << std::endl;
+                                )
+                                if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
+                                        unsigned nextExpl = results[i].nextExpl + 1;
+                                        if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
+                                        results.emplace_back(
+                                                i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ), nextArg,
+                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
+                                }
+                                continue;
+                        }
+                        // use default initializers if out of arguments
+                        if ( nextArg >= args.size() ) {
+                                if ( const ast::ConstantExpr * cnst = getDefaultValue( init ) ) {
+                                        ast::TypeEnvironment env = results[i].env;
+                                        ast::AssertionSet need = results[i].need, have = results[i].have;
+                                        ast::OpenVarSet open = results[i].open;
+                                        if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
+                                                results.emplace_back(
+                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, std::move( env ),
+                                                        std::move( need ), std::move( have ), std::move( open ), nextArg, nTuples );
+                                        }
+                                }
+                                continue;
+                        }
+                        // Check each possible next argument
+                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
+                                const ExplodedArg & expl = args[nextArg][j];
+                                // fresh copies of parent parameters for this iteration
+                                ast::TypeEnvironment env = results[i].env;
+                                ast::AssertionSet need = results[i].need, have = results[i].have;
+                                ast::OpenVarSet open = results[i].open;
+                                env.addActual( expl.env, open );
+                                // skip empty tuple arguments by (nearly) cloning parent into next gen
+                                if ( expl.exprs.empty() ) {
+                                        results.emplace_back(
+                                                results[i], std::move( env ), std::move( need ), std::move( have ), std::move( open ),
+                                                nextArg + 1, expl.cost );
+                                        continue;
+                                }
+                                // consider only first exploded arg
+                                const ast::Expr * expr = expl.exprs.front();
+                                const ast::Type * argType = expr->result;
+                                PRINT(
+                                        std::cerr << "param type is ";
+                                        ast::print( std::cerr, paramType );
+                                        std::cerr << std::endl << "arg type is ";
+                                        ast::print( std::cerr, argType );
+                                        std::cerr << std::endl;
+                                )
+                                // attempt to unify types
+                                if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
+                                        // add new result
+                                        results.emplace_back(
+                                                i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
+                                                nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                }
+                        }
+                }
+                // reset for next parameter
+                genStart = genEnd;
+                return genEnd != results.size();  // were any new results added?
+        }
+        /// Generate a cast expression from `arg` to `toType`
+        const ast::Expr * restructureCast(
+                ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated = ast::GeneratedCast
+        ) {
+                if (
+                        arg->result->size() > 1
+                        && ! toType->isVoid()
+                        && ! dynamic_cast< const ast::ReferenceType * >( toType )
+                ) {
+                        // Argument is a tuple and the target type is neither void nor a reference. Cast each
+                        // member of the tuple to its corresponding target type, producing the tuple of those
+                        // cast expressions. If there are more components of the tuple than components in the
+                        // target type, then excess components do not come out in the result expression (but
+                        // UniqueExpr ensures that the side effects will still be produced)
+                        if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
+                                // expressions which may contain side effects require a single unique instance of
+                                // the expression
+                                arg = new ast::UniqueExpr{ arg->location, arg };
+                        }
+                        std::vector< ast::ptr< ast::Expr > > components;
+                        for ( unsigned i = 0; i < toType->size(); ++i ) {
+                                // cast each component
+                                ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i };
+                                components.emplace_back(
+                                        restructureCast( idx, toType->getComponent( i ), isGenerated ) );
+                        }
+                        return new ast::TupleExpr{ arg->location, std::move( components ) };
+                } else {
+                        // handle normally
+                        return new ast::CastExpr{ arg->location, arg, toType, isGenerated };
+                }
+        }
+        /// Gets the name from an untyped member expression (must be NameExpr)
+        const std::string & getMemberName( const ast::UntypedMemberExpr * memberExpr ) {
+                if ( memberExpr->member.as< ast::ConstantExpr >() ) {
+                        SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
+                }
+                return memberExpr->member.strict_as< ast::NameExpr >()->name;
+        }
+        /// Actually visits expressions to find their candidate interpretations
+        class Finder final : public ast::WithShortCircuiting {
+                const ResolveContext & context;
+                const ast::SymbolTable & symtab;
+        public:
+                // static size_t traceId;
+                CandidateFinder & selfFinder;
+                CandidateList & candidates;
+                const ast::TypeEnvironment & tenv;
+                ast::ptr< ast::Type > & targetType;
+                enum Errors {
+                        NotFound,
+                        NoMatch,
+                        ArgsToFew,
+                        ArgsToMany,
+                        RetsToFew,
+                        RetsToMany,
+                        NoReason
+                };
+                struct {
+                        Errors code = NotFound;
+                } reason;
+                Finder( CandidateFinder & f )
+                : context( f.context ), symtab( context.symtab ), selfFinder( f ),
+                  candidates( f.candidates ), tenv( f.env ), targetType( f.targetType ) {}
+                void previsit( const ast::Node * ) { visit_children = false; }
+                /// Convenience to add candidate to list
+                template<typename... Args>
+                void addCandidate( Args &&... args ) {
+                        candidates.emplace_back( new Candidate{ std::forward<Args>( args )... } );
+                        reason.code = NoReason;
+                }
+                void postvisit( const ast::ApplicationExpr * applicationExpr ) {
+                        addCandidate( applicationExpr, tenv );
+                }
+                /// Set up candidate assertions for inference
+                void inferParameters( CandidateRef & newCand, CandidateList & out );
+                /// Completes a function candidate with arguments located
+                void validateFunctionCandidate(
+                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
+                        CandidateList & out );
+                /// Builds a list of candidates for a function, storing them in out
+                void makeFunctionCandidates(
+                        const CodeLocation & location,
+                        const CandidateRef & func, const ast::FunctionType * funcType,
+                        const ExplodedArgs_new & args, CandidateList & out );
+                /// Adds implicit struct-conversions to the alternative list
+                void addAnonConversions( const CandidateRef & cand );
+                /// Adds aggregate member interpretations
+                void addAggMembers(
+                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
+                        const Candidate & cand, const Cost & addedCost, const std::string & name
+                );
+                /// Adds tuple member interpretations
+                void addTupleMembers(
+                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
+                        const Cost & addedCost, const ast::Expr * member
+                );
+                /// true if expression is an lvalue
+                static bool isLvalue( const ast::Expr * x ) {
+                        return x->result && ( x->get_lvalue() || x->result.as< ast::ReferenceType >() );
+                }
+                void postvisit( const ast::UntypedExpr * untypedExpr );
+                void postvisit( const ast::VariableExpr * variableExpr );
+                void postvisit( const ast::ConstantExpr * constantExpr );
+                void postvisit( const ast::SizeofExpr * sizeofExpr );
+                void postvisit( const ast::AlignofExpr * alignofExpr );
+                void postvisit( const ast::AddressExpr * addressExpr );
+                void postvisit( const ast::LabelAddressExpr * labelExpr );
+                void postvisit( const ast::CastExpr * castExpr );
+                void postvisit( const ast::VirtualCastExpr * castExpr );
+                void postvisit( const ast::KeywordCastExpr * castExpr );
+                void postvisit( const ast::UntypedMemberExpr * memberExpr );
+                void postvisit( const ast::MemberExpr * memberExpr );
+                void postvisit( const ast::NameExpr * nameExpr );
+                void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr );
+                void postvisit( const ast::OffsetofExpr * offsetofExpr );
+                void postvisit( const ast::OffsetPackExpr * offsetPackExpr );
+                void postvisit( const ast::LogicalExpr * logicalExpr );
+                void postvisit( const ast::ConditionalExpr * conditionalExpr );
+                void postvisit( const ast::CommaExpr * commaExpr );
+                void postvisit( const ast::ImplicitCopyCtorExpr * ctorExpr );
+                void postvisit( const ast::ConstructorExpr * ctorExpr );
+                void postvisit( const ast::RangeExpr * rangeExpr );
+                void postvisit( const ast::UntypedTupleExpr * tupleExpr );
+                void postvisit( const ast::TupleExpr * tupleExpr );
+                void postvisit( const ast::TupleIndexExpr * tupleExpr );
+                void postvisit( const ast::TupleAssignExpr * tupleExpr );
+                void postvisit( const ast::UniqueExpr * unqExpr );
+                void postvisit( const ast::StmtExpr * stmtExpr );
+                void postvisit( const ast::UntypedInitExpr * initExpr );
+                void postvisit( const ast::InitExpr * ) {
+                        assertf( false, "CandidateFinder should never see a resolved InitExpr." );
+                }
+                void postvisit( const ast::DeletedExpr * ) {
+                        assertf( false, "CandidateFinder should never see a DeletedExpr." );
+                }
+                void postvisit( const ast::GenericExpr * ) {
+                        assertf( false, "_Generic is not yet supported." );
+                }
+        };
+        /// Set up candidate assertions for inference
+        void Finder::inferParameters( CandidateRef & newCand, CandidateList & out ) {
+                // Set need bindings for any unbound assertions
+                UniqueId crntResnSlot = 0; // matching ID for this expression's assertions
+                for ( auto & assn : newCand->need ) {
+                        // skip already-matched assertions
+                        if ( assn.second.resnSlot != 0 ) continue;
+                        // assign slot for expression if needed
+                        if ( crntResnSlot == 0 ) { crntResnSlot = ++globalResnSlot; }
+                        // fix slot to assertion
+                        assn.second.resnSlot = crntResnSlot;
+                }
+                // pair slot to expression
+                if ( crntResnSlot != 0 ) {
+                        newCand->expr.get_and_mutate()->inferred.resnSlots().emplace_back( crntResnSlot );
+                }
+                // add to output list; assertion satisfaction will occur later
+                out.emplace_back( newCand );
+        }
+        /// Completes a function candidate with arguments located
+        void Finder::validateFunctionCandidate(
+                const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
+                CandidateList & out
+        ) {
+                ast::ApplicationExpr * appExpr =
+                        new ast::ApplicationExpr{ func->expr->location, func->expr };
+                // sum cost and accumulate arguments
+                std::deque< const ast::Expr * > args;
+                Cost cost = func->cost;
+                const ArgPack * pack = &result;
+                while ( pack->expr ) {
+                        args.emplace_front( pack->expr );
+                        cost += pack->cost;
+                        pack = &results[pack->parent];
+                }
+                std::vector< ast::ptr< ast::Expr > > vargs( args.begin(), args.end() );
+                appExpr->args = std::move( vargs );
+                // build and validate new candidate
+                auto newCand =
+                        std::make_shared<Candidate>( appExpr, result.env, result.open, result.need, cost );
+                PRINT(
+                        std::cerr << "instantiate function success: " << appExpr << std::endl;
+                        std::cerr << "need assertions:" << std::endl;
+                        ast::print( std::cerr, result.need, 2 );
+                )
+                inferParameters( newCand, out );
+        }
+        /// Builds a list of candidates for a function, storing them in out
+        void Finder::makeFunctionCandidates(
+                const CodeLocation & location,
+                const CandidateRef & func, const ast::FunctionType * funcType,
+                const ExplodedArgs_new & args, CandidateList & out
+        ) {
+                ast::OpenVarSet funcOpen;
+                ast::AssertionSet funcNeed, funcHave;
+                ast::TypeEnvironment funcEnv{ func->env };
+                makeUnifiableVars( funcType, funcOpen, funcNeed );
+                // add all type variables as open variables now so that those not used in the
+                // parameter list are still considered open
+                funcEnv.add( funcType->forall );
+                if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
+                        // attempt to narrow based on expected target type
+                        const ast::Type * returnType = funcType->returns.front();
+                        if ( ! unify(
+                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
+                        ) {
+                                // unification failed, do not pursue this candidate
+                                return;
+                        }
+                }
+                // iteratively build matches, one parameter at a time
+                std::vector< ArgPack > results;
+                results.emplace_back( funcEnv, funcNeed, funcHave, funcOpen );
+                std::size_t genStart = 0;
+                // xxx - how to handle default arg after change to ftype representation?
+                if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
+                        if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
+                                // function may have default args only if directly calling by name
+                                // must use types on candidate however, due to RenameVars substitution
+                                auto nParams = funcType->params.size();
+                                for (size_t i=0; i<nParams; ++i) {
+                                        auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
+                                        if (!instantiateArgument( location,
+                                                funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                }
+                                goto endMatch;
+                        }
+                }
+                for ( const auto & param : funcType->params ) {
+                        // Try adding the arguments corresponding to the current parameter to the existing
+                        // matches
+                        // no default args for indirect calls
+                        if ( ! instantiateArgument( location,
+                                param, nullptr, args, results, genStart, symtab ) ) return;
+                }
+                endMatch:
+                if ( funcType->isVarArgs ) {
+                        // append any unused arguments to vararg pack
+                        std::size_t genEnd;
+                        do {
+                                genEnd = results.size();
+                                // iterate results
+                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
+                                        unsigned nextArg = results[i].nextArg;
+                                        // use remainder of exploded tuple if present
+                                        if ( results[i].hasExpl() ) {
+                                                const ExplodedArg & expl = results[i].getExpl( args );
+                                                unsigned nextExpl = results[i].nextExpl + 1;
+                                                if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
+                                                results.emplace_back(
+                                                        i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
+                                                        copy( results[i].need ), copy( results[i].have ),
+                                                        copy( results[i].open ), nextArg, 0, Cost::zero, nextExpl,
+                                                        results[i].explAlt );
+                                                continue;
+                                        }
+                                        // finish result when out of arguments
+                                        if ( nextArg >= args.size() ) {
+                                                validateFunctionCandidate( func, results[i], results, out );
+                                                continue;
+                                        }
+                                        // add each possible next argument
+                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
+                                                const ExplodedArg & expl = args[nextArg][j];
+                                                // fresh copies of parent parameters for this iteration
+                                                ast::TypeEnvironment env = results[i].env;
+                                                ast::OpenVarSet open = results[i].open;
+                                                env.addActual( expl.env, open );
+                                                // skip empty tuple arguments by (nearly) cloning parent into next gen
+                                                if ( expl.exprs.empty() ) {
+                                                        results.emplace_back(
+                                                                results[i], std::move( env ), copy( results[i].need ),
+                                                                copy( results[i].have ), std::move( open ), nextArg + 1,
+                                                                expl.cost );
+                                                        continue;
+                                                }
+                                                // add new result
+                                                results.emplace_back(
+                                                        i, expl.exprs.front(), std::move( env ), copy( results[i].need ),
+                                                        copy( results[i].have ), std::move( open ), nextArg + 1, 0, expl.cost,
+                                                        expl.exprs.size() == 1 ? 0 : 1, j );
+                                        }
+                                }
+                                genStart = genEnd;
+                        } while( genEnd != results.size() );
+                } else {
+                        // filter out the results that don't use all the arguments
+                        for ( std::size_t i = genStart; i < results.size(); ++i ) {
+                                ArgPack & result = results[i];
+                                if ( ! result.hasExpl() && result.nextArg >= args.size() ) {
+                                        validateFunctionCandidate( func, result, results, out );
+                                }
+                        }
+                }
+        }
+        /// Adds implicit struct-conversions to the alternative list
+        void Finder::addAnonConversions( const CandidateRef & cand ) {
+                // adds anonymous member interpretations whenever an aggregate value type is seen.
+                // it's okay for the aggregate expression to have reference type -- cast it to the
+                // base type to treat the aggregate as the referenced value
+                ast::ptr< ast::Expr > aggrExpr( cand->expr );
+                ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result;
+                cand->env.apply( aggrType );
+                if ( aggrType.as< ast::ReferenceType >() ) {
+                        aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() };
+                }
+                if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
+                        addAggMembers( structInst, aggrExpr, *cand, Cost::safe, "" );
+                } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
+                        addAggMembers( unionInst, aggrExpr, *cand, Cost::safe, "" );
+                }
+        }
+        /// Adds aggregate member interpretations
+        void Finder::addAggMembers(
+                const ast::BaseInstType * aggrInst, const ast::Expr * expr,
+                const Candidate & cand, const Cost & addedCost, const std::string & name
+        ) {
+                for ( const ast::Decl * decl : aggrInst->lookup( name ) ) {
+                        auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl );
+                        CandidateRef newCand = std::make_shared<Candidate>(
+                                cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
+                        // add anonymous member interpretations whenever an aggregate value type is seen
+                        // as a member expression
+                        addAnonConversions( newCand );
+                        candidates.emplace_back( std::move( newCand ) );
+                }
+        }
+        /// Adds tuple member interpretations
+        void Finder::addTupleMembers(
+                const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
+                const Cost & addedCost, const ast::Expr * member
+        ) {
+                if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) {
+                        // get the value of the constant expression as an int, must be between 0 and the
+                        // length of the tuple to have meaning
+                        long long val = constantExpr->intValue();
+                        if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
+                                addCandidate(
+                                        cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val },
+                                        addedCost );
+                        }
+                }
+        }
+        void Finder::postvisit( const ast::UntypedExpr * untypedExpr ) {
+                std::vector< CandidateFinder > argCandidates =
+                        selfFinder.findSubExprs( untypedExpr->args );
+                // take care of possible tuple assignments
+                // if not tuple assignment, handled as normal function call
+                Tuples::handleTupleAssignment( selfFinder, untypedExpr, argCandidates );
+                CandidateFinder funcFinder( context, tenv );
+                if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
+                        auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
+                        if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
+                                assertf(!argCandidates.empty(), "special function call without argument");
+                                for (auto & firstArgCand: argCandidates[0]) {
+                                        ast::ptr<ast::Type> argType = firstArgCand->expr->result;
+                                        firstArgCand->env.apply(argType);
+                                        // strip references
+                                        // xxx - is this correct?
+                                        while (argType.as<ast::ReferenceType>()) argType = argType.as<ast::ReferenceType>()->base;
+                                        // convert 1-tuple to plain type
+                                        if (auto tuple = argType.as<ast::TupleType>()) {
+                                                if (tuple->size() == 1) {
+                                                        argType = tuple->types[0];
+                                                }
+                                        }
+                                        // if argType is an unbound type parameter, all special functions need to be searched.
+                                        if (isUnboundType(argType)) {
+                                                funcFinder.otypeKeys.clear();
+                                                break;
+                                        }
+                                        if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
+                                        // else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
+                                        //      const ast::EnumDecl * enumDecl = enumInst->base; // Here
+                                        //      if ( const ast::Type* enumType = enumDecl->base ) {
+                                        //              // instance of enum (T) is a instance of type (T)
+                                        //              funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
+                                        //      } else {
+                                        //              // instance of an untyped enum is techically int
+                                        //              funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
+                                        //      }
+                                        // }
+                                        else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
+                                }
+                        }
+                }
+                // if candidates are already produced, do not fail
+                // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
+                // this means there exists ctor/assign functions with a tuple as first parameter.
+                ResolvMode mode = {
+                        true, // adjust
+                        !untypedExpr->func.as<ast::NameExpr>(), // prune if not calling by name
+                        selfFinder.candidates.empty() // failfast if other options are not found
+                };
+                funcFinder.find( untypedExpr->func, mode );
+                // short-circuit if no candidates
+                // if ( funcFinder.candidates.empty() ) return;
+                reason.code = NoMatch;
+                // find function operators
+                ast::ptr< ast::Expr > opExpr = new ast::NameExpr{ untypedExpr->location, "?()" }; // ??? why not ?{}
+                CandidateFinder opFinder( context, tenv );
+                // okay if there aren't any function operations
+                opFinder.find( opExpr, ResolvMode::withoutFailFast() );
+                PRINT(
+                        std::cerr << "known function ops:" << std::endl;
+                        print( std::cerr, opFinder.candidates, 1 );
+                )
+                // pre-explode arguments
+                ExplodedArgs_new argExpansions;
+                for ( const CandidateFinder & args : argCandidates ) {
+                        argExpansions.emplace_back();
+                        auto & argE = argExpansions.back();
+                        for ( const CandidateRef & arg : args ) { argE.emplace_back( *arg, symtab ); }
+                }
+                // Find function matches
+                CandidateList found;
+                SemanticErrorException errors;
+                for ( CandidateRef & func : funcFinder ) {
+                        try {
+                                PRINT(
+                                        std::cerr << "working on alternative:" << std::endl;
+                                        print( std::cerr, *func, 2 );
+                                )
+                                // check if the type is a pointer to function
+                                const ast::Type * funcResult = func->expr->result->stripReferences();
+                                if ( auto pointer = dynamic_cast< const ast::PointerType * >( funcResult ) ) {
+                                        if ( auto function = pointer->base.as< ast::FunctionType >() ) {
+                                                CandidateRef newFunc{ new Candidate{ *func } };
+                                                newFunc->expr =
+                                                        referenceToRvalueConversion( newFunc->expr, newFunc->cost );
+                                                makeFunctionCandidates( untypedExpr->location,
+                                                        newFunc, function, argExpansions, found );
+                                        }
+                                } else if (
+                                        auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
+                                ) {
+                                        if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
+                                                if ( auto function = clz->bound.as< ast::FunctionType >() ) {
+                                                        CandidateRef newFunc{ new Candidate{ *func } };
+                                                        newFunc->expr =
+                                                                referenceToRvalueConversion( newFunc->expr, newFunc->cost );
+                                                        makeFunctionCandidates( untypedExpr->location,
+                                                                newFunc, function, argExpansions, found );
+                                                }
+                                        }
+                                }
+                        } catch ( SemanticErrorException & e ) { errors.append( e ); }
+                }
+                // Find matches on function operators `?()`
+                if ( ! opFinder.candidates.empty() ) {
+                        // add exploded function alternatives to front of argument list
+                        std::vector< ExplodedArg > funcE;
+                        funcE.reserve( funcFinder.candidates.size() );
+                        for ( const CandidateRef & func : funcFinder ) {
+                                funcE.emplace_back( *func, symtab );
+                        }
+                        argExpansions.emplace_front( std::move( funcE ) );
+                        for ( const CandidateRef & op : opFinder ) {
+                                try {
+                                        // check if type is pointer-to-function
+                                        const ast::Type * opResult = op->expr->result->stripReferences();
+                                        if ( auto pointer = dynamic_cast< const ast::PointerType * >( opResult ) ) {
+                                                if ( auto function = pointer->base.as< ast::FunctionType >() ) {
+                                                        CandidateRef newOp{ new Candidate{ *op} };
+                                                        newOp->expr =
+                                                                referenceToRvalueConversion( newOp->expr, newOp->cost );
+                                                        makeFunctionCandidates( untypedExpr->location,
+                                                                newOp, function, argExpansions, found );
+                                                }
+                                        }
+                                } catch ( SemanticErrorException & e ) { errors.append( e ); }
+                        }
+                }
+                // Implement SFINAE; resolution errors are only errors if there aren't any non-error
+                // candidates
+                if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
+                // Compute conversion costs
+                for ( CandidateRef & withFunc : found ) {
+                        Cost cvtCost = computeApplicationConversionCost( withFunc, symtab );
+                        PRINT(
+                                auto appExpr = withFunc->expr.strict_as< ast::ApplicationExpr >();
+                                auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
+                                auto function = pointer->base.strict_as< ast::FunctionType >();
+                                std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl;
+                                std::cerr << "parameters are:" << std::endl;
+                                ast::printAll( std::cerr, function->params, 2 );
+                                std::cerr << "arguments are:" << std::endl;
+                                ast::printAll( std::cerr, appExpr->args, 2 );
+                                std::cerr << "bindings are:" << std::endl;
+                                ast::print( std::cerr, withFunc->env, 2 );
+                                std::cerr << "cost is: " << withFunc->cost << std::endl;
+                                std::cerr << "cost of conversion is:" << cvtCost << std::endl;
+                        )
+                        if ( cvtCost != Cost::infinity ) {
+                                withFunc->cvtCost = cvtCost;
+                                candidates.emplace_back( std::move( withFunc ) );
+                        }
+                }
+                found = std::move( candidates );
+                // use a new list so that candidates are not examined by addAnonConversions twice
+                CandidateList winners = findMinCost( found );
+                promoteCvtCost( winners );
+                // function may return a struct/union value, in which case we need to add candidates
+                // for implicit conversions to each of the anonymous members, which must happen after
+                // `findMinCost`, since anon conversions are never the cheapest
+                for ( const CandidateRef & c : winners ) {
+                        addAnonConversions( c );
+                }
+                spliceBegin( candidates, winners );
+                if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
+                        // If resolution is unsuccessful with a target type, try again without, since it
+                        // will sometimes succeed when it wouldn't with a target type binding.
+                        // For example:
+                        //   forall( otype T ) T & ?[]( T *, ptrdiff_t );
+                        //   const char * x = "hello world";
+                        //   unsigned char ch = x[0];
+                        // Fails with simple return type binding (xxx -- check this!) as follows:
+                        // * T is bound to unsigned char
+                        // * (x: const char *) is unified with unsigned char *, which fails
+                        // xxx -- fix this better
+                        targetType = nullptr;
+                        postvisit( untypedExpr );
+                }
+        }
+        void Finder::postvisit( const ast::AddressExpr * addressExpr ) {
+                CandidateFinder finder( context, tenv );
+                finder.find( addressExpr->arg );
+                if ( finder.candidates.empty() ) return;
+                reason.code = NoMatch;
+                for ( CandidateRef & r : finder.candidates ) {
+                        if ( ! isLvalue( r->expr ) ) continue;
+                        addCandidate( *r, new ast::AddressExpr{ addressExpr->location, r->expr } );
+                }
+        }
+        void Finder::postvisit( const ast::LabelAddressExpr * labelExpr ) {
+                addCandidate( labelExpr, tenv );
+        }
+        void Finder::postvisit( const ast::CastExpr * castExpr ) {
+                ast::ptr< ast::Type > toType = castExpr->result;
+                assert( toType );
+                toType = resolveTypeof( toType, context );
+                toType = adjustExprType( toType, tenv, symtab );
+                CandidateFinder finder( context, tenv, toType );
+                finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+                if ( !finder.candidates.empty() ) reason.code = NoMatch;
+                CandidateList matches;
+                for ( CandidateRef & cand : finder.candidates ) {
+                        ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
+                        ast::OpenVarSet open( cand->open );
+                        cand->env.extractOpenVars( open );
+                        // It is possible that a cast can throw away some values in a multiply-valued
+                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the
+                        // subexpression results that are cast directly. The candidate is invalid if it
+                        // has fewer results than there are types to cast to.
+                        int discardedValues = cand->expr->result->size() - toType->size();
+                        if ( discardedValues < 0 ) continue;
+                        // unification run for side-effects
+                        unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
+                        Cost thisCost =
+                                (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
+                                        ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
+                                        : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
+                        PRINT(
+                                std::cerr << "working on cast with result: " << toType << std::endl;
+                                std::cerr << "and expr type: " << cand->expr->result << std::endl;
+                                std::cerr << "env: " << cand->env << std::endl;
+                        )
+                        if ( thisCost != Cost::infinity ) {
+                                PRINT(
+                                        std::cerr << "has finite cost." << std::endl;
+                                )
+                                // count one safe conversion for each value that is thrown away
+                                thisCost.incSafe( discardedValues );
+                                CandidateRef newCand = std::make_shared<Candidate>(
+                                        restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                        copy( cand->env ), std::move( open ), std::move( need ), cand->cost,
+                                        cand->cost + thisCost );
+                                inferParameters( newCand, matches );
+                        }
+                }
+                // select first on argument cost, then conversion cost
+                CandidateList minArgCost = findMinCost( matches );
+                promoteCvtCost( minArgCost );
+                candidates = findMinCost( minArgCost );
+        }
+        void Finder::postvisit( const ast::VirtualCastExpr * castExpr ) {
+                assertf( castExpr->result, "Implicit virtual cast targets not yet supported." );
+                CandidateFinder finder( context, tenv );
+                // don't prune here, all alternatives guaranteed to have same type
+                finder.find( castExpr->arg, ResolvMode::withoutPrune() );
+                for ( CandidateRef & r : finder.candidates ) {
+                        addCandidate(
+                                *r,
+                                new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
+                }
+        }
+        void Finder::postvisit( const ast::KeywordCastExpr * castExpr ) {
+                const auto & loc = castExpr->location;
+                assertf( castExpr->result, "Cast target should have been set in Validate." );
+                auto ref = castExpr->result.strict_as<ast::ReferenceType>();
+                auto inst = ref->base.strict_as<ast::StructInstType>();
+                auto target = inst->base.get();
+                CandidateFinder finder( context, tenv );
+                auto pick_alternatives = [target, this](CandidateList & found, bool expect_ref) {
+                        for (auto & cand : found) {
+                                const ast::Type * expr = cand->expr->result.get();
+                                if (expect_ref) {
+                                        auto res = dynamic_cast<const ast::ReferenceType*>(expr);
+                                        if (!res) { continue; }
+                                        expr = res->base.get();
+                                }
+                                if (auto insttype = dynamic_cast<const ast::TypeInstType*>(expr)) {
+                                        auto td = cand->env.lookup(*insttype);
+                                        if (!td) { continue; }
+                                        expr = td->bound.get();
+                                }
+                                if (auto base = dynamic_cast<const ast::StructInstType*>(expr)) {
+                                        if (base->base == target) {
+                                                candidates.push_back( std::move(cand) );
+                                                reason.code = NoReason;
+                                        }
+                                }
+                        }
+                };
+                try {
+                        // Attempt 1 : turn (thread&)X into (thread$&)X.__thrd
+                        // Clone is purely for memory management
+                        std::unique_ptr<const ast::Expr> tech1 { new ast::UntypedMemberExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.field), castExpr->arg) };
+                        // don't prune here, since it's guaranteed all alternatives will have the same type
+                        finder.find( tech1.get(), ResolvMode::withoutPrune() );
+                        pick_alternatives(finder.candidates, false);
+                        return;
+                } catch(SemanticErrorException & ) {}
+                // Fallback : turn (thread&)X into (thread$&)get_thread(X)
+                std::unique_ptr<const ast::Expr> fallback { ast::UntypedExpr::createDeref(loc,  new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) };
+                // don't prune here, since it's guaranteed all alternatives will have the same type
+                finder.find( fallback.get(), ResolvMode::withoutPrune() );
+                pick_alternatives(finder.candidates, true);
+                // Whatever happens here, we have no more fallbacks
+        }
+        void Finder::postvisit( const ast::UntypedMemberExpr * memberExpr ) {
+                CandidateFinder aggFinder( context, tenv );
+                aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
+                for ( CandidateRef & agg : aggFinder.candidates ) {
+                        // it's okay for the aggregate expression to have reference type -- cast it to the
+                        // base type to treat the aggregate as the referenced value
+                        Cost addedCost = Cost::zero;
+                        agg->expr = referenceToRvalueConversion( agg->expr, addedCost );
+                        // find member of the given type
+                        if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) {
+                                addAggMembers(
+                                        structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
+                        } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) {
+                                addAggMembers(
+                                        unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
+                        } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) {
+                                addTupleMembers( tupleType, agg->expr, *agg, addedCost, memberExpr->member );
+                        }
+                }
+        }
+        void Finder::postvisit( const ast::MemberExpr * memberExpr ) {
+                addCandidate( memberExpr, tenv );
+        }
+        void Finder::postvisit( const ast::NameExpr * nameExpr ) {
+                std::vector< ast::SymbolTable::IdData > declList;
+                if (!selfFinder.otypeKeys.empty()) {
+                        auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
+                        assertf(kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS, "special lookup with non-special target: %s", nameExpr->name.c_str());
+                        for (auto & otypeKey: selfFinder.otypeKeys) {
+                                auto result = symtab.specialLookupId(kind, otypeKey);
+                                declList.insert(declList.end(), std::make_move_iterator(result.begin()), std::make_move_iterator(result.end()));
+                        }
+                } else {
+                        declList = symtab.lookupId( nameExpr->name );
+                }
+                PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
+                if ( declList.empty() ) return;
+                reason.code = NoMatch;
+                for ( auto & data : declList ) {
+                        Cost cost = Cost::zero;
+                        ast::Expr * newExpr = data.combine( nameExpr->location, cost );
+                        CandidateRef newCand = std::make_shared<Candidate>(
+                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
+                                cost );
+                        if (newCand->expr->env) {
+                                newCand->env.add(*newCand->expr->env);
+                                auto mutExpr = newCand->expr.get_and_mutate();
+                                mutExpr->env  = nullptr;
+                                newCand->expr = mutExpr;
+                        }
+                        PRINT(
+                                std::cerr << "decl is ";
+                                ast::print( std::cerr, data.id );
+                                std::cerr << std::endl;
+                                std::cerr << "newExpr is ";
+                                ast::print( std::cerr, newExpr );
+                                std::cerr << std::endl;
+                        )
+                        newCand->expr = ast::mutate_field(
+                                newCand->expr.get(), &ast::Expr::result,
+                                renameTyVars( newCand->expr->result ) );
+                        // add anonymous member interpretations whenever an aggregate value type is seen
+                        // as a name expression
+                        addAnonConversions( newCand );
+                        candidates.emplace_back( std::move( newCand ) );
+                }
+        }
+        void Finder::postvisit( const ast::VariableExpr * variableExpr ) {
+                // not sufficient to just pass `variableExpr` here, type might have changed since
+                // creation
+                addCandidate(
+                        new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
+        }
+        void Finder::postvisit( const ast::ConstantExpr * constantExpr ) {
+                addCandidate( constantExpr, tenv );
+        }
+        void Finder::postvisit( const ast::SizeofExpr * sizeofExpr ) {
+                if ( sizeofExpr->type ) {
+                        addCandidate(
+                                new ast::SizeofExpr{
+                                        sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
+                                tenv );
+                } else {
+                        // find all candidates for the argument to sizeof
+                        CandidateFinder finder( context, tenv );
+                        finder.find( sizeofExpr->expr );
+                        // find the lowest-cost candidate, otherwise ambiguous
+                        CandidateList winners = findMinCost( finder.candidates );
+                        if ( winners.size() != 1 ) {
+                                SemanticError(
+                                        sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
+                        }
+                        // return the lowest-cost candidate
+                        CandidateRef & choice = winners.front();
+                        choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+                        choice->cost = Cost::zero;
+                        addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
+                }
+        }
+        void Finder::postvisit( const ast::AlignofExpr * alignofExpr ) {
+                if ( alignofExpr->type ) {
+                        addCandidate(
+                                new ast::AlignofExpr{
+                                        alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
+                                tenv );
+                } else {
+                        // find all candidates for the argument to alignof
+                        CandidateFinder finder( context, tenv );
+                        finder.find( alignofExpr->expr );
+                        // find the lowest-cost candidate, otherwise ambiguous
+                        CandidateList winners = findMinCost( finder.candidates );
+                        if ( winners.size() != 1 ) {
+                                SemanticError(
+                                        alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
+                        }
+                        // return the lowest-cost candidate
+                        CandidateRef & choice = winners.front();
+                        choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+                        choice->cost = Cost::zero;
+                        addCandidate(
+                                *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
+                }
+        }
+        void Finder::postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
+                const ast::BaseInstType * aggInst;
+                if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
+                else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;
+                else return;
+                for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
+                        auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
+                        addCandidate(
+                                new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
+                }
+        }
+        void Finder::postvisit( const ast::OffsetofExpr * offsetofExpr ) {
+                addCandidate( offsetofExpr, tenv );
+        }
+        void Finder::postvisit( const ast::OffsetPackExpr * offsetPackExpr ) {
+                addCandidate( offsetPackExpr, tenv );
+        }
+        void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
+                CandidateFinder finder1( context, tenv );
+                finder1.find( logicalExpr->arg1, ResolvMode::withAdjustment() );
+                if ( finder1.candidates.empty() ) return;
+                CandidateFinder finder2( context, tenv );
+                finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() );
+                if ( finder2.candidates.empty() ) return;
+                reason.code = NoMatch;
+                for ( const CandidateRef & r1 : finder1.candidates ) {
+                        for ( const CandidateRef & r2 : finder2.candidates ) {
+                                ast::TypeEnvironment env{ r1->env };
+                                env.simpleCombine( r2->env );
+                                ast::OpenVarSet open{ r1->open };
+                                mergeOpenVars( open, r2->open );
+                                ast::AssertionSet need;
+                                mergeAssertionSet( need, r1->need );
+                                mergeAssertionSet( need, r2->need );
+                                addCandidate(
+                                        new ast::LogicalExpr{
+                                                logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd },
+                                        std::move( env ), std::move( open ), std::move( need ), r1->cost + r2->cost );
+                        }
+                }
+        }
+        void Finder::postvisit( const ast::ConditionalExpr * conditionalExpr ) {
+                // candidates for condition
+                CandidateFinder finder1( context, tenv );
+                finder1.find( conditionalExpr->arg1, ResolvMode::withAdjustment() );
+                if ( finder1.candidates.empty() ) return;
+                // candidates for true result
+                CandidateFinder finder2( context, tenv );
+                finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
+                if ( finder2.candidates.empty() ) return;
+                // candidates for false result
+                CandidateFinder finder3( context, tenv );
+                finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
+                if ( finder3.candidates.empty() ) return;
+                reason.code = NoMatch;
+                for ( const CandidateRef & r1 : finder1.candidates ) {
+                        for ( const CandidateRef & r2 : finder2.candidates ) {
+                                for ( const CandidateRef & r3 : finder3.candidates ) {
+                                        ast::TypeEnvironment env{ r1->env };
+                                        env.simpleCombine( r2->env );
+                                        env.simpleCombine( r3->env );
+                                        ast::OpenVarSet open{ r1->open };
+                                        mergeOpenVars( open, r2->open );
+                                        mergeOpenVars( open, r3->open );
+                                        ast::AssertionSet need;
+                                        mergeAssertionSet( need, r1->need );
+                                        mergeAssertionSet( need, r2->need );
+                                        mergeAssertionSet( need, r3->need );
+                                        ast::AssertionSet have;
+                                        // unify true and false results, then infer parameters to produce new
+                                        // candidates
+                                        ast::ptr< ast::Type > common;
+                                        if (
+                                                unify(
+                                                        r2->expr->result, r3->expr->result, env, need, have, open, symtab,
+                                                        common )
+                                        ) {
+                                                // generate typed expression
+                                                ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{
+                                                        conditionalExpr->location, r1->expr, r2->expr, r3->expr };
+                                                newExpr->result = common ? common : r2->expr->result;
+                                                // convert both options to result type
+                                                Cost cost = r1->cost + r2->cost + r3->cost;
+                                                newExpr->arg2 = computeExpressionConversionCost(
+                                                        newExpr->arg2, newExpr->result, symtab, env, cost );
+                                                newExpr->arg3 = computeExpressionConversionCost(
+                                                        newExpr->arg3, newExpr->result, symtab, env, cost );
+                                                // output candidate
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        newExpr, std::move( env ), std::move( open ), std::move( need ), cost );
+                                                inferParameters( newCand, candidates );
+                                        }
+                                }
+                        }
+                }
+        }
+        void Finder::postvisit( const ast::CommaExpr * commaExpr ) {
+                ast::TypeEnvironment env{ tenv };
+                ast::ptr< ast::Expr > arg1 = resolveInVoidContext( commaExpr->arg1, context, env );
+                CandidateFinder finder2( context, env );
+                finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
+                for ( const CandidateRef & r2 : finder2.candidates ) {
+                        addCandidate( *r2, new ast::CommaExpr{ commaExpr->location, arg1, r2->expr } );
+                }
+        }
+        void Finder::postvisit( const ast::ImplicitCopyCtorExpr * ctorExpr ) {
+                addCandidate( ctorExpr, tenv );
+        }
+        void Finder::postvisit( const ast::ConstructorExpr * ctorExpr ) {
+                CandidateFinder finder( context, tenv );
+                finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
+                for ( CandidateRef & r : finder.candidates ) {
+                        addCandidate( *r, new ast::ConstructorExpr{ ctorExpr->location, r->expr } );
+                }
+        }
+        void Finder::postvisit( const ast::RangeExpr * rangeExpr ) {
+                // resolve low and high, accept candidates where low and high types unify
+                CandidateFinder finder1( context, tenv );
+                finder1.find( rangeExpr->low, ResolvMode::withAdjustment() );
+                if ( finder1.candidates.empty() ) return;
+                CandidateFinder finder2( context, tenv );
+                finder2.find( rangeExpr->high, ResolvMode::withAdjustment() );
+                if ( finder2.candidates.empty() ) return;
+                reason.code = NoMatch;
+                for ( const CandidateRef & r1 : finder1.candidates ) {
+                        for ( const CandidateRef & r2 : finder2.candidates ) {
+                                ast::TypeEnvironment env{ r1->env };
+                                env.simpleCombine( r2->env );
+                                ast::OpenVarSet open{ r1->open };
+                                mergeOpenVars( open, r2->open );
+                                ast::AssertionSet need;
+                                mergeAssertionSet( need, r1->need );
+                                mergeAssertionSet( need, r2->need );
+                                ast::AssertionSet have;
+                                ast::ptr< ast::Type > common;
+                                if (
+                                        unify(
+                                                r1->expr->result, r2->expr->result, env, need, have, open, symtab,
+                                                common )
+                                ) {
+                                        // generate new expression
+                                        ast::RangeExpr * newExpr =
+                                                new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr };
+                                        newExpr->result = common ? common : r1->expr->result;
+                                        // add candidate
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                newExpr, std::move( env ), std::move( open ), std::move( need ),
+                                                r1->cost + r2->cost );
+                                        inferParameters( newCand, candidates );
+                                }
+                        }
+                }
+        }
+        void Finder::postvisit( const ast::UntypedTupleExpr * tupleExpr ) {
+                std::vector< CandidateFinder > subCandidates =
+                        selfFinder.findSubExprs( tupleExpr->exprs );
+                std::vector< CandidateList > possibilities;
+                combos( subCandidates.begin(), subCandidates.end(), back_inserter( possibilities ) );
+                for ( const CandidateList & subs : possibilities ) {
+                        std::vector< ast::ptr< ast::Expr > > exprs;
+                        exprs.reserve( subs.size() );
+                        for ( const CandidateRef & sub : subs ) { exprs.emplace_back( sub->expr ); }
+                        ast::TypeEnvironment env;
+                        ast::OpenVarSet open;
+                        ast::AssertionSet need;
+                        for ( const CandidateRef & sub : subs ) {
+                                env.simpleCombine( sub->env );
+                                mergeOpenVars( open, sub->open );
+                                mergeAssertionSet( need, sub->need );
+                        }
+                        addCandidate(
+                                new ast::TupleExpr{ tupleExpr->location, std::move( exprs ) },
+                                std::move( env ), std::move( open ), std::move( need ), sumCost( subs ) );
+                }
+        }
+        void Finder::postvisit( const ast::TupleExpr * tupleExpr ) {
+                addCandidate( tupleExpr, tenv );
+        }
+        void Finder::postvisit( const ast::TupleIndexExpr * tupleExpr ) {
+                addCandidate( tupleExpr, tenv );
+        }
+        void Finder::postvisit( const ast::TupleAssignExpr * tupleExpr ) {
+                addCandidate( tupleExpr, tenv );
+        }
+        void Finder::postvisit( const ast::UniqueExpr * unqExpr ) {
+                CandidateFinder finder( context, tenv );
+                finder.find( unqExpr->expr, ResolvMode::withAdjustment() );
+                for ( CandidateRef & r : finder.candidates ) {
+                        // ensure that the the id is passed on so that the expressions are "linked"
+                        addCandidate( *r, new ast::UniqueExpr{ unqExpr->location, r->expr, unqExpr->id } );
+                }
+        }
+        void Finder::postvisit( const ast::StmtExpr * stmtExpr ) {
+                addCandidate( resolveStmtExpr( stmtExpr, context ), tenv );
+        }
+        void Finder::postvisit( const ast::UntypedInitExpr * initExpr ) {
+                // handle each option like a cast
+                CandidateList matches;
+                PRINT(
+                        std::cerr << "untyped init expr: " << initExpr << std::endl;
+                )
+                // O(n^2) checks of d-types with e-types
+                for ( const ast::InitAlternative & initAlt : initExpr->initAlts ) {
+                        // calculate target type
+                        const ast::Type * toType = resolveTypeof( initAlt.type, context );
+                        toType = adjustExprType( toType, tenv, symtab );
+                        // The call to find must occur inside this loop, otherwise polymorphic return
+                        // types are not bound to the initialization type, since return type variables are
+                        // only open for the duration of resolving the UntypedExpr.
+                        CandidateFinder finder( context, tenv, toType );
+                        finder.find( initExpr->expr, ResolvMode::withAdjustment() );
+                        for ( CandidateRef & cand : finder.candidates ) {
+                                if (reason.code == NotFound) reason.code = NoMatch;
+                                ast::TypeEnvironment env{ cand->env };
+                                ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
+                                ast::OpenVarSet open{ cand->open };
+                                PRINT(
+                                        std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
+                                )
+                                // It is possible that a cast can throw away some values in a multiply-valued
+                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of
+                                // the subexpression results that are cast directly. The candidate is invalid
+                                // if it has fewer results than there are types to cast to.
+                                int discardedValues = cand->expr->result->size() - toType->size();
+                                if ( discardedValues < 0 ) continue;
+                                // unification run for side-effects
+                                bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                (void) canUnify;
+                                Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                        symtab, env );
+                                PRINT(
+                                        Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                symtab, env );
+                                        std::cerr << "Considering initialization:";
+                                        std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
+                                        std::cerr << std::endl << "  TO: "   << toType             << std::endl;
+                                        std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                        std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                        std::cerr << std::endl << "  New cost " << thisCost;
+                                        std::cerr << std::endl;
+                                )
+                                if ( thisCost != Cost::infinity ) {
+                                        // count one safe conversion for each value that is thrown away
+                                        thisCost.incSafe( discardedValues );
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                new ast::InitExpr{
+                                                        initExpr->location, restructureCast( cand->expr, toType ),
+                                                        initAlt.designation },
+                                                std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost );
+                                        inferParameters( newCand, matches );
+                                }
+                        }
+                }
+                // select first on argument cost, then conversion cost
+                CandidateList minArgCost = findMinCost( matches );
+                promoteCvtCost( minArgCost );
+                candidates = findMinCost( minArgCost );
+        }
+        // size_t Finder::traceId = Stats::Heap::new_stacktrace_id("Finder");
+        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
+        /// return type. Skips ambiguous candidates.
+} // anonymous namespace
+bool CandidateFinder::pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector<std::string> & errors ) {
+        struct PruneStruct {
+                CandidateRef candidate;
+                bool ambiguous;
+                PruneStruct() = default;
+                PruneStruct( const CandidateRef & c ) : candidate( c ), ambiguous( false ) {}
+        };
+        // find lowest-cost candidate for each type
+        std::unordered_map< std::string, PruneStruct > selected;
+        // attempt to skip satisfyAssertions on more expensive alternatives if better options have been found
+        std::sort(candidates.begin(), candidates.end(), [](const CandidateRef & x, const CandidateRef & y){return x->cost < y->cost;});
+        for ( CandidateRef & candidate : candidates ) {
+                std::string mangleName;
+                {
+                        ast::ptr< ast::Type > newType = candidate->expr->result;
+                        assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
+                        candidate->env.apply( newType );
+                        mangleName = Mangle::mangle( newType );
+                }
+                auto found = selected.find( mangleName );
+                if (found != selected.end() && found->second.candidate->cost < candidate->cost) {
+                        PRINT(
+                                std::cerr << "cost " << candidate->cost << " loses to "
+                                        << found->second.candidate->cost << std::endl;
+                        )
+                        continue;
+                }
+                // xxx - when do satisfyAssertions produce more than 1 result?
+                // this should only happen when initial result type contains
+                // unbound type parameters, then it should never be pruned by
+                // the previous step, since renameTyVars guarantees the mangled name
+                // is unique.
+                CandidateList satisfied;
+                bool needRecomputeKey = false;
+                if (candidate->need.empty()) {
+                        satisfied.emplace_back(candidate);
+                }
+                else {
+                        satisfyAssertions(candidate, context.symtab, satisfied, errors);
+                        needRecomputeKey = true;
+                }
+                for (auto & newCand : satisfied) {
+                        // recomputes type key, if satisfyAssertions changed it
+                        if (needRecomputeKey)
+                        {
+                                ast::ptr< ast::Type > newType = newCand->expr->result;
+                                assertf(newCand->expr->result, "Result of expression %p for candidate is null", newCand->expr.get());
+                                newCand->env.apply( newType );
+                                mangleName = Mangle::mangle( newType );
+                        }
+                        auto found = selected.find( mangleName );
+                        if ( found != selected.end() ) {
+                                if ( newCand->cost < found->second.candidate->cost ) {
+                                        PRINT(
+                                                std::cerr << "cost " << newCand->cost << " beats "
+                                                        << found->second.candidate->cost << std::endl;
+                                        )
+                                        found->second = PruneStruct{ newCand };
+                                } else if ( newCand->cost == found->second.candidate->cost ) {
+                                        // if one of the candidates contains a deleted identifier, can pick the other,
+                                        // since deleted expressions should not be ambiguous if there is another option
+                                        // that is at least as good
+                                        if ( findDeletedExpr( newCand->expr ) ) {
+                                                // do nothing
+                                                PRINT( std::cerr << "candidate is deleted" << std::endl; )
+                                        } else if ( findDeletedExpr( found->second.candidate->expr ) ) {
+                                                PRINT( std::cerr << "current is deleted" << std::endl; )
+                                                found->second = PruneStruct{ newCand };
+                                        } else {
+                                                PRINT( std::cerr << "marking ambiguous" << std::endl; )
+                                                found->second.ambiguous = true;
+                                        }
+                                } else {
+                                        // xxx - can satisfyAssertions increase the cost?
+                                        PRINT(
+                                                std::cerr << "cost " << newCand->cost << " loses to "
+                                                        << found->second.candidate->cost << std::endl;
+                                        )
+                                }
+                        } else {
+                                selected.emplace_hint( found, mangleName, newCand );
+                        }
+                }
+        }
+        // report unambiguous min-cost candidates
+        // CandidateList out;
+        for ( auto & target : selected ) {
+                if ( target.second.ambiguous ) continue;
+                CandidateRef cand = target.second.candidate;
+                ast::ptr< ast::Type > newResult = cand->expr->result;
+                cand->env.applyFree( newResult );
+                cand->expr = ast::mutate_field(
+                        cand->expr.get(), &ast::Expr::result, std::move( newResult ) );
+                out.emplace_back( cand );
+        }
+        // if everything is lost in satisfyAssertions, report the error
+        return !selected.empty();
+}
+void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
+        // Find alternatives for expression
+        ast::Pass<Finder> finder{ *this };
+        expr->accept( finder );
+        if ( mode.failFast && candidates.empty() ) {
+                switch(finder.core.reason.code) {
+                case Finder::NotFound:
+                        { SemanticError( expr, "No alternatives for expression " ); break; }
+                case Finder::NoMatch:
+                        { SemanticError( expr, "Invalid application of existing declaration(s) in expression " ); break; }
+                case Finder::ArgsToFew:
+                case Finder::ArgsToMany:
+                case Finder::RetsToFew:
+                case Finder::RetsToMany:
+                case Finder::NoReason:
+                default:
+                        { SemanticError( expr->location, "No reasonable alternatives for expression : reasons unkown" ); }
+                }
+        }
+        /*
+        if ( mode.satisfyAssns || mode.prune ) {
+                // trim candidates to just those where the assertions are satisfiable
+                // - necessary pre-requisite to pruning
+                CandidateList satisfied;
+                std::vector< std::string > errors;
+                for ( CandidateRef & candidate : candidates ) {
+                        satisfyAssertions( candidate, localSyms, satisfied, errors );
+                }
+                // fail early if none such
+                if ( mode.failFast && satisfied.empty() ) {
+                        std::ostringstream stream;
+                        stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                        for ( const auto& err : errors ) {
+                                stream << err;
+                        }
+                        SemanticError( expr->location, stream.str() );
+                }
+                // reset candidates
+                candidates = move( satisfied );
+        }
+        */
+        if ( mode.prune ) {
+                // trim candidates to single best one
+                PRINT(
+                        std::cerr << "alternatives before prune:" << std::endl;
+                        print( std::cerr, candidates );
+                )
+                CandidateList pruned;
+                std::vector<std::string> errors;
+                bool found = pruneCandidates( candidates, pruned, errors );
+                if ( mode.failFast && pruned.empty() ) {
+                        std::ostringstream stream;
+                        if (found) {
+                                CandidateList winners = findMinCost( candidates );
+                                stream << "Cannot choose between " << winners.size() << " alternatives for "
+                                        "expression\n";
+                                ast::print( stream, expr );
+                                stream << " Alternatives are:\n";
+                                print( stream, winners, 1 );
+                                SemanticError( expr->location, stream.str() );
+                        }
+                        else {
+                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                                for ( const auto& err : errors ) {
+                                        stream << err;
+                                }
+                                SemanticError( expr->location, stream.str() );
+                        }
+                }
+                auto oldsize = candidates.size();
+                candidates = std::move( pruned );
+                PRINT(
+                        std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
+                )
+                PRINT(
+                        std::cerr << "there are " << candidates.size() << " alternatives after elimination"
+                                << std::endl;
+                )
+        }
+        // adjust types after pruning so that types substituted by pruneAlternatives are correctly
+        // adjusted
+        if ( mode.adjust ) {
+                for ( CandidateRef & r : candidates ) {
+                        r->expr = ast::mutate_field(
+                                r->expr.get(), &ast::Expr::result,
+                                adjustExprType( r->expr->result, r->env, context.symtab ) );
+                }
+        }
+        // Central location to handle gcc extension keyword, etc. for all expressions
+        for ( CandidateRef & r : candidates ) {
+                if ( r->expr->extension != expr->extension ) {
+                        r->expr.get_and_mutate()->extension = expr->extension;
+                }
+        }
+}
+std::vector< CandidateFinder > CandidateFinder::findSubExprs(
+        const std::vector< ast::ptr< ast::Expr > > & xs
+) {
+        std::vector< CandidateFinder > out;
+        for ( const auto & x : xs ) {
+                out.emplace_back( context, env );
+                out.back().find( x, ResolvMode::withAdjustment() );
+                PRINT(
+                        std::cerr << "findSubExprs" << std::endl;
+                        print( std::cerr, out.back().candidates );
+                )
+        }
+        return out;
+}
 const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost ) {
         if ( expr->result.as< ast::ReferenceType >() ) {
 …
         return expr;
+}
-/// Unique identifier for matching expression resolutions to their requesting expression
-UniqueId globalResnSlot = 0;
 Cost computeConversionCost(
 …
+}
-namespace {
-        /// First index is which argument, second is which alternative, third is which exploded element
-        using ExplodedArgs_new = std::deque< std::vector< ExplodedArg > >;
-        /// Returns a list of alternatives with the minimum cost in the given list
-        CandidateList findMinCost( const CandidateList & candidates ) {
-                CandidateList out;
-                Cost minCost = Cost::infinity;
-                for ( const CandidateRef & r : candidates ) {
-                        if ( r->cost < minCost ) {
-                                minCost = r->cost;
-                                out.clear();
-                                out.emplace_back( r );
-                        } else if ( r->cost == minCost ) {
-                                out.emplace_back( r );
+                        }
+                }
-                return out;
+        }
-        /// Computes conversion cost for a given expression to a given type
-        const ast::Expr * computeExpressionConversionCost(
-                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
-        ) {
-                Cost convCost = computeConversionCost(
-                                arg->result, paramType, arg->get_lvalue(), symtab, env );
-                outCost += convCost;
-                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires
-                // conversion. Ignore poly cost for now, since this requires resolution of the cast to
-                // infer parameters and this does not currently work for the reason stated below
-                Cost tmpCost = convCost;
-                tmpCost.incPoly( -tmpCost.get_polyCost() );
-                if ( tmpCost != Cost::zero ) {
-                        ast::ptr< ast::Type > newType = paramType;
-                        env.apply( newType );
-                        return new ast::CastExpr{ arg, newType };
-                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not
-                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent,
-                        // once this is fixed it should be possible to resolve the cast.
-                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable,
-                        // but it shouldn't be because this makes the conversion from DT* to DT* since
-                        // commontype(zero_t, DT*) is DT*, rather than nothing
-                        // CandidateFinder finder{ symtab, env };
-                        // finder.find( arg, ResolvMode::withAdjustment() );
-                        // assertf( finder.candidates.size() > 0,
-                        //      "Somehow castable expression failed to find alternatives." );
-                        // assertf( finder.candidates.size() == 1,
-                        //      "Somehow got multiple alternatives for known cast expression." );
-                        // return finder.candidates.front()->expr;
+                }
-                return arg;
+        }
-        /// Computes conversion cost for a given candidate
-        Cost computeApplicationConversionCost(
-                CandidateRef cand, const ast::SymbolTable & symtab
-        ) {
-                auto appExpr = cand->expr.strict_as< ast::ApplicationExpr >();
-                auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
-                auto function = pointer->base.strict_as< ast::FunctionType >();
-                Cost convCost = Cost::zero;
-                const auto & params = function->params;
-                auto param = params.begin();
-                auto & args = appExpr->args;
-                for ( unsigned i = 0; i < args.size(); ++i ) {
-                        const ast::Type * argType = args[i]->result;
-                        PRINT(
-                                std::cerr << "arg expression:" << std::endl;
-                                ast::print( std::cerr, args[i], 2 );
-                                std::cerr << "--- results are" << std::endl;
-                                ast::print( std::cerr, argType, 2 );
+                        )
-                        if ( param == params.end() ) {
-                                if ( function->isVarArgs ) {
-                                        convCost.incUnsafe();
-                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: "
-                                                << convCost << std::endl; ; )
-                                        // convert reference-typed expressions into value-typed expressions
-                                        cand->expr = ast::mutate_field_index(
-                                                appExpr, &ast::ApplicationExpr::args, i,
-                                                referenceToRvalueConversion( args[i], convCost ) );
-                                        continue;
-                                } else return Cost::infinity;
+                        }
-                        if ( auto def = args[i].as< ast::DefaultArgExpr >() ) {
-                                // Default arguments should be free - don't include conversion cost.
-                                // Unwrap them here because they are not relevant to the rest of the system
-                                cand->expr = ast::mutate_field_index(
-                                        appExpr, &ast::ApplicationExpr::args, i, def->expr );
-                                ++param;
-                                continue;
+                        }
-                        // mark conversion cost and also specialization cost of param type
-                        // const ast::Type * paramType = (*param)->get_type();
-                        cand->expr = ast::mutate_field_index(
-                                appExpr, &ast::ApplicationExpr::args, i,
-                                computeExpressionConversionCost(
-                                        args[i], *param, symtab, cand->env, convCost ) );
-                        convCost.decSpec( specCost( *param ) );
-                        ++param;  // can't be in for-loop update because of the continue
+                }
-                if ( param != params.end() ) return Cost::infinity;
-                // specialization cost of return types can't be accounted for directly, it disables
-                // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
-                //
-                //   forall(otype OS) {
-                //     void ?|?(OS&, int);  // with newline
-                //     OS&  ?|?(OS&, int);  // no newline, always chosen due to more specialization
-                //   }
-                // mark type variable and specialization cost of forall clause
-                convCost.incVar( function->forall.size() );
-                convCost.decSpec( function->assertions.size() );
-                return convCost;
+        }
-        void makeUnifiableVars(
-                const ast::FunctionType * type, ast::OpenVarSet & unifiableVars,
-                ast::AssertionSet & need
-        ) {
-                for ( auto & tyvar : type->forall ) {
-                        unifiableVars[ *tyvar ] = ast::TypeData{ tyvar->base };
+                }
-                for ( auto & assn : type->assertions ) {
-                        need[ assn ].isUsed = true;
+                }
+        }
-        /// Gets a default value from an initializer, nullptr if not present
-        const ast::ConstantExpr * getDefaultValue( const ast::Init * init ) {
-                if ( auto si = dynamic_cast< const ast::SingleInit * >( init ) ) {
-                        if ( auto ce = si->value.as< ast::CastExpr >() ) {
-                                return ce->arg.as< ast::ConstantExpr >();
-                        } else {
-                                return si->value.as< ast::ConstantExpr >();
+                        }
+                }
-                return nullptr;
+        }
-        /// State to iteratively build a match of parameter expressions to arguments
-        struct ArgPack {
-                std::size_t parent;          ///< Index of parent pack
-                ast::ptr< ast::Expr > expr;  ///< The argument stored here
-                Cost cost;                   ///< The cost of this argument
-                ast::TypeEnvironment env;    ///< Environment for this pack
-                ast::AssertionSet need;      ///< Assertions outstanding for this pack
-                ast::AssertionSet have;      ///< Assertions found for this pack
-                ast::OpenVarSet open;        ///< Open variables for this pack
-                unsigned nextArg;            ///< Index of next argument in arguments list
-                unsigned tupleStart;         ///< Number of tuples that start at this index
-                unsigned nextExpl;           ///< Index of next exploded element
-                unsigned explAlt;            ///< Index of alternative for nextExpl > 0
-                ArgPack()
-                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ),
-                  tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
-                ArgPack(
-                        const ast::TypeEnvironment & env, const ast::AssertionSet & need,
-                        const ast::AssertionSet & have, const ast::OpenVarSet & open )
-                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ),
-                  open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
-                ArgPack(
-                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env,
-                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open,
-                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
-                        unsigned nextExpl = 0, unsigned explAlt = 0 )
-                : parent(parent), expr( expr ), cost( cost ), env( std::move( env ) ), need( std::move( need ) ),
-                  have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
-                  nextExpl( nextExpl ), explAlt( explAlt ) {}
-                ArgPack(
-                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
-                        ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added )
-                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( std::move( env ) ),
-                  need( std::move( need ) ), have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ),
-                  tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {}
-                /// true if this pack is in the middle of an exploded argument
-                bool hasExpl() const { return nextExpl > 0; }
-                /// Gets the list of exploded candidates for this pack
-                const ExplodedArg & getExpl( const ExplodedArgs_new & args ) const {
-                        return args[ nextArg-1 ][ explAlt ];
+                }
-                /// Ends a tuple expression, consolidating the appropriate args
-                void endTuple( const std::vector< ArgPack > & packs ) {
-                        // add all expressions in tuple to list, summing cost
-                        std::deque< const ast::Expr * > exprs;
-                        const ArgPack * pack = this;
-                        if ( expr ) { exprs.emplace_front( expr ); }
-                        while ( pack->tupleStart == 0 ) {
-                                pack = &packs[pack->parent];
-                                exprs.emplace_front( pack->expr );
-                                cost += pack->cost;
+                        }
-                        // reset pack to appropriate tuple
-                        std::vector< ast::ptr< ast::Expr > > exprv( exprs.begin(), exprs.end() );
-                        expr = new ast::TupleExpr{ expr->location, std::move( exprv ) };
-                        tupleStart = pack->tupleStart - 1;
-                        parent = pack->parent;
+                }
-        };
-        /// Instantiates an argument to match a parameter, returns false if no matching results left
-        bool instantiateArgument(
-                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
-                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
-                unsigned nTuples = 0
-        ) {
-                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( paramType ) ) {
-                        // paramType is a TupleType -- group args into a TupleExpr
-                        ++nTuples;
-                        for ( const ast::Type * type : *tupleType ) {
-                                // xxx - dropping initializer changes behaviour from previous, but seems correct
-                                // ^^^ need to handle the case where a tuple has a default argument
-                                if ( ! instantiateArgument(
-                                        type, nullptr, args, results, genStart, symtab, nTuples ) ) return false;
-                                nTuples = 0;
+                        }
-                        // re-constitute tuples for final generation
-                        for ( auto i = genStart; i < results.size(); ++i ) {
-                                results[i].endTuple( results );
+                        }
-                        return true;
-                } else if ( const ast::TypeInstType * ttype = Tuples::isTtype( paramType ) ) {
-                        // paramType is a ttype, consumes all remaining arguments
-                        // completed tuples; will be spliced to end of results to finish
-                        std::vector< ArgPack > finalResults{};
-                        // iterate until all results completed
-                        std::size_t genEnd;
-                        ++nTuples;
-                        do {
-                                genEnd = results.size();
-                                // add another argument to results
-                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
-                                        unsigned nextArg = results[i].nextArg;
-                                        // use next element of exploded tuple if present
-                                        if ( results[i].hasExpl() ) {
-                                                const ExplodedArg & expl = results[i].getExpl( args );
-                                                unsigned nextExpl = results[i].nextExpl + 1;
-                                                if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
-                                                results.emplace_back(
-                                                        i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
-                                                        copy( results[i].need ), copy( results[i].have ),
-                                                        copy( results[i].open ), nextArg, nTuples, Cost::zero, nextExpl,
-                                                        results[i].explAlt );
-                                                continue;
+                                        }
-                                        // finish result when out of arguments
-                                        if ( nextArg >= args.size() ) {
-                                                ArgPack newResult{
-                                                        results[i].env, results[i].need, results[i].have, results[i].open };
-                                                newResult.nextArg = nextArg;
-                                                const ast::Type * argType = nullptr;
-                                                if ( nTuples > 0 || ! results[i].expr ) {
-                                                        // first iteration or no expression to clone,
-                                                        // push empty tuple expression
-                                                        newResult.parent = i;
-                                                        newResult.expr = new ast::TupleExpr{ CodeLocation{}, {} };
-                                                        argType = newResult.expr->result;
-                                                } else {
-                                                        // clone result to collect tuple
-                                                        newResult.parent = results[i].parent;
-                                                        newResult.cost = results[i].cost;
-                                                        newResult.tupleStart = results[i].tupleStart;
-                                                        newResult.expr = results[i].expr;
-                                                        argType = newResult.expr->result;
-                                                        if ( results[i].tupleStart > 0 && Tuples::isTtype( argType ) ) {
-                                                                // the case where a ttype value is passed directly is special,
-                                                                // e.g. for argument forwarding purposes
-                                                                // xxx - what if passing multiple arguments, last of which is
-                                                                //       ttype?
-                                                                // xxx - what would happen if unify was changed so that unifying
-                                                                //       tuple
-                                                                // types flattened both before unifying lists? then pass in
-                                                                // TupleType (ttype) below.
-                                                                --newResult.tupleStart;
-                                                        } else {
-                                                                // collapse leftover arguments into tuple
-                                                                newResult.endTuple( results );
-                                                                argType = newResult.expr->result;
+                                                        }
+                                                }
-                                                // check unification for ttype before adding to final
-                                                if (
-                                                        unify(
-                                                                ttype, argType, newResult.env, newResult.need, newResult.have,
-                                                                newResult.open, symtab )
-                                                ) {
-                                                        finalResults.emplace_back( std::move( newResult ) );
+                                                }
-                                                continue;
+                                        }
-                                        // add each possible next argument
-                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
-                                                const ExplodedArg & expl = args[nextArg][j];
-                                                // fresh copies of parent parameters for this iteration
-                                                ast::TypeEnvironment env = results[i].env;
-                                                ast::OpenVarSet open = results[i].open;
-                                                env.addActual( expl.env, open );
-                                                // skip empty tuple arguments by (nearly) cloning parent into next gen
-                                                if ( expl.exprs.empty() ) {
-                                                        results.emplace_back(
-                                                                results[i], std::move( env ), copy( results[i].need ),
-                                                                copy( results[i].have ), std::move( open ), nextArg + 1, expl.cost );
-                                                        continue;
+                                                }
-                                                // add new result
-                                                results.emplace_back(
-                                                        i, expl.exprs.front(), std::move( env ), copy( results[i].need ),
-                                                        copy( results[i].have ), std::move( open ), nextArg + 1, nTuples,
-                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                        }
+                                }
-                                // reset for next round
-                                genStart = genEnd;
-                                nTuples = 0;
-                        } while ( genEnd != results.size() );
-                        // splice final results onto results
-                        for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
-                                results.emplace_back( std::move( finalResults[i] ) );
+                        }
-                        return ! finalResults.empty();
+                }
-                // iterate each current subresult
-                std::size_t genEnd = results.size();
-                for ( std::size_t i = genStart; i < genEnd; ++i ) {
-                        unsigned nextArg = results[i].nextArg;
-                        // use remainder of exploded tuple if present
-                        if ( results[i].hasExpl() ) {
-                                const ExplodedArg & expl = results[i].getExpl( args );
-                                const ast::Expr * expr = expl.exprs[ results[i].nextExpl ];
-                                ast::TypeEnvironment env = results[i].env;
-                                ast::AssertionSet need = results[i].need, have = results[i].have;
-                                ast::OpenVarSet open = results[i].open;
-                                const ast::Type * argType = expr->result;
-                                PRINT(
-                                        std::cerr << "param type is ";
-                                        ast::print( std::cerr, paramType );
-                                        std::cerr << std::endl << "arg type is ";
-                                        ast::print( std::cerr, argType );
-                                        std::cerr << std::endl;
+                                )
-                                if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
-                                        unsigned nextExpl = results[i].nextExpl + 1;
-                                        if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
-                                        results.emplace_back(
-                                                i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ), nextArg,
-                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
+                                }
-                                continue;
+                        }
-                        // use default initializers if out of arguments
-                        if ( nextArg >= args.size() ) {
-                                if ( const ast::ConstantExpr * cnst = getDefaultValue( init ) ) {
-                                        ast::TypeEnvironment env = results[i].env;
-                                        ast::AssertionSet need = results[i].need, have = results[i].have;
-                                        ast::OpenVarSet open = results[i].open;
-                                        if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
-                                                results.emplace_back(
-                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, std::move( env ),
-                                                        std::move( need ), std::move( have ), std::move( open ), nextArg, nTuples );
+                                        }
+                                }
-                                continue;
+                        }
-                        // Check each possible next argument
-                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
-                                const ExplodedArg & expl = args[nextArg][j];
-                                // fresh copies of parent parameters for this iteration
-                                ast::TypeEnvironment env = results[i].env;
-                                ast::AssertionSet need = results[i].need, have = results[i].have;
-                                ast::OpenVarSet open = results[i].open;
-                                env.addActual( expl.env, open );
-                                // skip empty tuple arguments by (nearly) cloning parent into next gen
-                                if ( expl.exprs.empty() ) {
-                                        results.emplace_back(
-                                                results[i], std::move( env ), std::move( need ), std::move( have ), std::move( open ),
-                                                nextArg + 1, expl.cost );
-                                        continue;
+                                }
-                                // consider only first exploded arg
-                                const ast::Expr * expr = expl.exprs.front();
-                                const ast::Type * argType = expr->result;
-                                PRINT(
-                                        std::cerr << "param type is ";
-                                        ast::print( std::cerr, paramType );
-                                        std::cerr << std::endl << "arg type is ";
-                                        ast::print( std::cerr, argType );
-                                        std::cerr << std::endl;
+                                )
-                                // attempt to unify types
-                                if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
-                                        // add new result
-                                        results.emplace_back(
-                                                i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
-                                                nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                }
+                        }
+                }
-                // reset for next parameter
-                genStart = genEnd;
-                return genEnd != results.size();  // were any new results added?
+        }
-        /// Generate a cast expression from `arg` to `toType`
-        const ast::Expr * restructureCast(
-                ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated = ast::GeneratedCast
-        ) {
-                if (
-                        arg->result->size() > 1
-                        && ! toType->isVoid()
-                        && ! dynamic_cast< const ast::ReferenceType * >( toType )
-                ) {
-                        // Argument is a tuple and the target type is neither void nor a reference. Cast each
-                        // member of the tuple to its corresponding target type, producing the tuple of those
-                        // cast expressions. If there are more components of the tuple than components in the
-                        // target type, then excess components do not come out in the result expression (but
-                        // UniqueExpr ensures that the side effects will still be produced)
-                        if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
-                                // expressions which may contain side effects require a single unique instance of
-                                // the expression
-                                arg = new ast::UniqueExpr{ arg->location, arg };
+                        }
-                        std::vector< ast::ptr< ast::Expr > > components;
-                        for ( unsigned i = 0; i < toType->size(); ++i ) {
-                                // cast each component
-                                ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i };
-                                components.emplace_back(
-                                        restructureCast( idx, toType->getComponent( i ), isGenerated ) );
+                        }
-                        return new ast::TupleExpr{ arg->location, std::move( components ) };
-                } else {
-                        // handle normally
-                        return new ast::CastExpr{ arg->location, arg, toType, isGenerated };
+                }
+        }
-        /// Gets the name from an untyped member expression (must be NameExpr)
-        const std::string & getMemberName( const ast::UntypedMemberExpr * memberExpr ) {
-                if ( memberExpr->member.as< ast::ConstantExpr >() ) {
-                        SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
+                }
-                return memberExpr->member.strict_as< ast::NameExpr >()->name;
+        }
-        /// Actually visits expressions to find their candidate interpretations
-        class Finder final : public ast::WithShortCircuiting {
-                const ResolveContext & context;
-                const ast::SymbolTable & symtab;
-        public:
-                // static size_t traceId;
-                CandidateFinder & selfFinder;
-                CandidateList & candidates;
-                const ast::TypeEnvironment & tenv;
-                ast::ptr< ast::Type > & targetType;
-                enum Errors {
-                        NotFound,
-                        NoMatch,
-                        ArgsToFew,
-                        ArgsToMany,
-                        RetsToFew,
-                        RetsToMany,
-                        NoReason
-                };
-                struct {
-                        Errors code = NotFound;
-                } reason;
-                Finder( CandidateFinder & f )
-                : context( f.context ), symtab( context.symtab ), selfFinder( f ),
-                  candidates( f.candidates ), tenv( f.env ), targetType( f.targetType ) {}
-                void previsit( const ast::Node * ) { visit_children = false; }
-                /// Convenience to add candidate to list
-                template<typename... Args>
-                void addCandidate( Args &&... args ) {
-                        candidates.emplace_back( new Candidate{ std::forward<Args>( args )... } );
-                        reason.code = NoReason;
+                }
-                void postvisit( const ast::ApplicationExpr * applicationExpr ) {
-                        addCandidate( applicationExpr, tenv );
+                }
-                /// Set up candidate assertions for inference
-                void inferParameters( CandidateRef & newCand, CandidateList & out ) {
-                        // Set need bindings for any unbound assertions
-                        UniqueId crntResnSlot = 0; // matching ID for this expression's assertions
-                        for ( auto & assn : newCand->need ) {
-                                // skip already-matched assertions
-                                if ( assn.second.resnSlot != 0 ) continue;
-                                // assign slot for expression if needed
-                                if ( crntResnSlot == 0 ) { crntResnSlot = ++globalResnSlot; }
-                                // fix slot to assertion
-                                assn.second.resnSlot = crntResnSlot;
+                        }
-                        // pair slot to expression
-                        if ( crntResnSlot != 0 ) {
-                                newCand->expr.get_and_mutate()->inferred.resnSlots().emplace_back( crntResnSlot );
+                        }
-                        // add to output list; assertion satisfaction will occur later
-                        out.emplace_back( newCand );
+                }
-                /// Completes a function candidate with arguments located
-                void validateFunctionCandidate(
-                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
-                        CandidateList & out
-                ) {
-                        ast::ApplicationExpr * appExpr =
-                                new ast::ApplicationExpr{ func->expr->location, func->expr };
-                        // sum cost and accumulate arguments
-                        std::deque< const ast::Expr * > args;
-                        Cost cost = func->cost;
-                        const ArgPack * pack = &result;
-                        while ( pack->expr ) {
-                                args.emplace_front( pack->expr );
-                                cost += pack->cost;
-                                pack = &results[pack->parent];
+                        }
-                        std::vector< ast::ptr< ast::Expr > > vargs( args.begin(), args.end() );
-                        appExpr->args = std::move( vargs );
-                        // build and validate new candidate
-                        auto newCand =
-                                std::make_shared<Candidate>( appExpr, result.env, result.open, result.need, cost );
-                        PRINT(
-                                std::cerr << "instantiate function success: " << appExpr << std::endl;
-                                std::cerr << "need assertions:" << std::endl;
-                                ast::print( std::cerr, result.need, 2 );
+                        )
-                        inferParameters( newCand, out );
+                }
-                /// Builds a list of candidates for a function, storing them in out
-                void makeFunctionCandidates(
-                        const CandidateRef & func, const ast::FunctionType * funcType,
-                        const ExplodedArgs_new & args, CandidateList & out
-                ) {
-                        ast::OpenVarSet funcOpen;
-                        ast::AssertionSet funcNeed, funcHave;
-                        ast::TypeEnvironment funcEnv{ func->env };
-                        makeUnifiableVars( funcType, funcOpen, funcNeed );
-                        // add all type variables as open variables now so that those not used in the
-                        // parameter list are still considered open
-                        funcEnv.add( funcType->forall );
-                        if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
-                                // attempt to narrow based on expected target type
-                                const ast::Type * returnType = funcType->returns.front();
-                                if ( ! unify(
-                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
-                                ) {
-                                        // unification failed, do not pursue this candidate
-                                        return;
+                                }
+                        }
-                        // iteratively build matches, one parameter at a time
-                        std::vector< ArgPack > results;
-                        results.emplace_back( funcEnv, funcNeed, funcHave, funcOpen );
-                        std::size_t genStart = 0;
-                        // xxx - how to handle default arg after change to ftype representation?
-                        if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
-                                if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
-                                        // function may have default args only if directly calling by name
-                                        // must use types on candidate however, due to RenameVars substitution
-                                        auto nParams = funcType->params.size();
-                                        for (size_t i=0; i<nParams; ++i) {
-                                                auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
-                                                if (!instantiateArgument(
-                                                        funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                        }
-                                        goto endMatch;
+                                }
+                        }
-                        for ( const auto & param : funcType->params ) {
-                                // Try adding the arguments corresponding to the current parameter to the existing
-                                // matches
-                                // no default args for indirect calls
-                                if ( ! instantiateArgument(
-                                        param, nullptr, args, results, genStart, symtab ) ) return;
+                        }
-                        endMatch:
-                        if ( funcType->isVarArgs ) {
-                                // append any unused arguments to vararg pack
-                                std::size_t genEnd;
-                                do {
-                                        genEnd = results.size();
-                                        // iterate results
-                                        for ( std::size_t i = genStart; i < genEnd; ++i ) {
-                                                unsigned nextArg = results[i].nextArg;
-                                                // use remainder of exploded tuple if present
-                                                if ( results[i].hasExpl() ) {
-                                                        const ExplodedArg & expl = results[i].getExpl( args );
-                                                        unsigned nextExpl = results[i].nextExpl + 1;
-                                                        if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
-                                                        results.emplace_back(
-                                                                i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
-                                                                copy( results[i].need ), copy( results[i].have ),
-                                                                copy( results[i].open ), nextArg, 0, Cost::zero, nextExpl,
-                                                                results[i].explAlt );
-                                                        continue;
+                                                }
-                                                // finish result when out of arguments
-                                                if ( nextArg >= args.size() ) {
-                                                        validateFunctionCandidate( func, results[i], results, out );
-                                                        continue;
+                                                }
-                                                // add each possible next argument
-                                                for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
-                                                        const ExplodedArg & expl = args[nextArg][j];
-                                                        // fresh copies of parent parameters for this iteration
-                                                        ast::TypeEnvironment env = results[i].env;
-                                                        ast::OpenVarSet open = results[i].open;
-                                                        env.addActual( expl.env, open );
-                                                        // skip empty tuple arguments by (nearly) cloning parent into next gen
-                                                        if ( expl.exprs.empty() ) {
-                                                                results.emplace_back(
-                                                                        results[i], std::move( env ), copy( results[i].need ),
-                                                                        copy( results[i].have ), std::move( open ), nextArg + 1,
-                                                                        expl.cost );
-                                                                continue;
+                                                        }
-                                                        // add new result
-                                                        results.emplace_back(
-                                                                i, expl.exprs.front(), std::move( env ), copy( results[i].need ),
-                                                                copy( results[i].have ), std::move( open ), nextArg + 1, 0, expl.cost,
-                                                                expl.exprs.size() == 1 ? 0 : 1, j );
+                                                }
+                                        }
-                                        genStart = genEnd;
-                                } while( genEnd != results.size() );
-                        } else {
-                                // filter out the results that don't use all the arguments
-                                for ( std::size_t i = genStart; i < results.size(); ++i ) {
-                                        ArgPack & result = results[i];
-                                        if ( ! result.hasExpl() && result.nextArg >= args.size() ) {
-                                                validateFunctionCandidate( func, result, results, out );
+                                        }
+                                }
+                        }
+                }
-                /// Adds implicit struct-conversions to the alternative list
-                void addAnonConversions( const CandidateRef & cand ) {
-                        // adds anonymous member interpretations whenever an aggregate value type is seen.
-                        // it's okay for the aggregate expression to have reference type -- cast it to the
-                        // base type to treat the aggregate as the referenced value
-                        ast::ptr< ast::Expr > aggrExpr( cand->expr );
-                        ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result;
-                        cand->env.apply( aggrType );
-                        if ( aggrType.as< ast::ReferenceType >() ) {
-                                aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() };
+                        }
-                        if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
-                                addAggMembers( structInst, aggrExpr, *cand, Cost::safe, "" );
-                        } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
-                                addAggMembers( unionInst, aggrExpr, *cand, Cost::safe, "" );
+                        }
+                }
-                /// Adds aggregate member interpretations
-                void addAggMembers(
-                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
-                        const Candidate & cand, const Cost & addedCost, const std::string & name
-                ) {
-                        for ( const ast::Decl * decl : aggrInst->lookup( name ) ) {
-                                auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl );
-                                CandidateRef newCand = std::make_shared<Candidate>(
-                                        cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
-                                // add anonymous member interpretations whenever an aggregate value type is seen
-                                // as a member expression
-                                addAnonConversions( newCand );
-                                candidates.emplace_back( std::move( newCand ) );
+                        }
+                }
-                /// Adds tuple member interpretations
-                void addTupleMembers(
-                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
-                        const Cost & addedCost, const ast::Expr * member
-                ) {
-                        if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) {
-                                // get the value of the constant expression as an int, must be between 0 and the
-                                // length of the tuple to have meaning
-                                long long val = constantExpr->intValue();
-                                if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
-                                        addCandidate(
-                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val },
-                                                addedCost );
+                                }
+                        }
+                }
-                void postvisit( const ast::UntypedExpr * untypedExpr ) {
-                        std::vector< CandidateFinder > argCandidates =
-                                selfFinder.findSubExprs( untypedExpr->args );
-                        // take care of possible tuple assignments
-                        // if not tuple assignment, handled as normal function call
-                        Tuples::handleTupleAssignment( selfFinder, untypedExpr, argCandidates );
-                        CandidateFinder funcFinder( context, tenv );
-                        if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
-                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
-                                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
-                                        assertf(!argCandidates.empty(), "special function call without argument");
-                                        for (auto & firstArgCand: argCandidates[0]) {
-                                                ast::ptr<ast::Type> argType = firstArgCand->expr->result;
-                                                firstArgCand->env.apply(argType);
-                                                // strip references
-                                                // xxx - is this correct?
-                                                while (argType.as<ast::ReferenceType>()) argType = argType.as<ast::ReferenceType>()->base;
-                                                // convert 1-tuple to plain type
-                                                if (auto tuple = argType.as<ast::TupleType>()) {
-                                                        if (tuple->size() == 1) {
-                                                                argType = tuple->types[0];
+                                                        }
+                                                }
-                                                // if argType is an unbound type parameter, all special functions need to be searched.
-                                                if (isUnboundType(argType)) {
-                                                        funcFinder.otypeKeys.clear();
-                                                        break;
+                                                }
-                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
-                                                // else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
-                                                //      const ast::EnumDecl * enumDecl = enumInst->base; // Here
-                                                //      if ( const ast::Type* enumType = enumDecl->base ) {
-                                                //              // instance of enum (T) is a instance of type (T)
-                                                //              funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
-                                                //      } else {
-                                                //              // instance of an untyped enum is techically int
-                                                //              funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
-                                                //      }
-                                                // }
-                                                else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
+                                        }
+                                }
+                        }
-                        // if candidates are already produced, do not fail
-                        // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
-                        // this means there exists ctor/assign functions with a tuple as first parameter.
-                        ResolvMode mode = {
-                                true, // adjust
-                                !untypedExpr->func.as<ast::NameExpr>(), // prune if not calling by name
-                                selfFinder.candidates.empty() // failfast if other options are not found
-                        };
-                        funcFinder.find( untypedExpr->func, mode );
-                        // short-circuit if no candidates
-                        // if ( funcFinder.candidates.empty() ) return;
-                        reason.code = NoMatch;
-                        // find function operators
-                        ast::ptr< ast::Expr > opExpr = new ast::NameExpr{ untypedExpr->location, "?()" }; // ??? why not ?{}
-                        CandidateFinder opFinder( context, tenv );
-                        // okay if there aren't any function operations
-                        opFinder.find( opExpr, ResolvMode::withoutFailFast() );
-                        PRINT(
-                                std::cerr << "known function ops:" << std::endl;
-                                print( std::cerr, opFinder.candidates, 1 );
+                        )
-                        // pre-explode arguments
-                        ExplodedArgs_new argExpansions;
-                        for ( const CandidateFinder & args : argCandidates ) {
-                                argExpansions.emplace_back();
-                                auto & argE = argExpansions.back();
-                                for ( const CandidateRef & arg : args ) { argE.emplace_back( *arg, symtab ); }
+                        }
-                        // Find function matches
-                        CandidateList found;
-                        SemanticErrorException errors;
-                        for ( CandidateRef & func : funcFinder ) {
-                                try {
-                                        PRINT(
-                                                std::cerr << "working on alternative:" << std::endl;
-                                                print( std::cerr, *func, 2 );
+                                        )
-                                        // check if the type is a pointer to function
-                                        const ast::Type * funcResult = func->expr->result->stripReferences();
-                                        if ( auto pointer = dynamic_cast< const ast::PointerType * >( funcResult ) ) {
-                                                if ( auto function = pointer->base.as< ast::FunctionType >() ) {
-                                                        CandidateRef newFunc{ new Candidate{ *func } };
-                                                        newFunc->expr =
-                                                                referenceToRvalueConversion( newFunc->expr, newFunc->cost );
-                                                        makeFunctionCandidates( newFunc, function, argExpansions, found );
+                                                }
-                                        } else if (
-                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
-                                        ) {
-                                                if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
-                                                        if ( auto function = clz->bound.as< ast::FunctionType >() ) {
-                                                                CandidateRef newFunc{ new Candidate{ *func } };
-                                                                newFunc->expr =
-                                                                        referenceToRvalueConversion( newFunc->expr, newFunc->cost );
-                                                                makeFunctionCandidates( newFunc, function, argExpansions, found );
+                                                        }
+                                                }
+                                        }
-                                } catch ( SemanticErrorException & e ) { errors.append( e ); }
+                        }
-                        // Find matches on function operators `?()`
-                        if ( ! opFinder.candidates.empty() ) {
-                                // add exploded function alternatives to front of argument list
-                                std::vector< ExplodedArg > funcE;
-                                funcE.reserve( funcFinder.candidates.size() );
-                                for ( const CandidateRef & func : funcFinder ) {
-                                        funcE.emplace_back( *func, symtab );
+                                }
-                                argExpansions.emplace_front( std::move( funcE ) );
-                                for ( const CandidateRef & op : opFinder ) {
-                                        try {
-                                                // check if type is pointer-to-function
-                                                const ast::Type * opResult = op->expr->result->stripReferences();
-                                                if ( auto pointer = dynamic_cast< const ast::PointerType * >( opResult ) ) {
-                                                        if ( auto function = pointer->base.as< ast::FunctionType >() ) {
-                                                                CandidateRef newOp{ new Candidate{ *op} };
-                                                                newOp->expr =
-                                                                        referenceToRvalueConversion( newOp->expr, newOp->cost );
-                                                                makeFunctionCandidates( newOp, function, argExpansions, found );
+                                                        }
+                                                }
-                                        } catch ( SemanticErrorException & e ) { errors.append( e ); }
+                                }
+                        }
-                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error
-                        // candidates
-                        if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
-                        // Compute conversion costs
-                        for ( CandidateRef & withFunc : found ) {
-                                Cost cvtCost = computeApplicationConversionCost( withFunc, symtab );
-                                PRINT(
-                                        auto appExpr = withFunc->expr.strict_as< ast::ApplicationExpr >();
-                                        auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
-                                        auto function = pointer->base.strict_as< ast::FunctionType >();
-                                        std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl;
-                                        std::cerr << "parameters are:" << std::endl;
-                                        ast::printAll( std::cerr, function->params, 2 );
-                                        std::cerr << "arguments are:" << std::endl;
-                                        ast::printAll( std::cerr, appExpr->args, 2 );
-                                        std::cerr << "bindings are:" << std::endl;
-                                        ast::print( std::cerr, withFunc->env, 2 );
-                                        std::cerr << "cost is: " << withFunc->cost << std::endl;
-                                        std::cerr << "cost of conversion is:" << cvtCost << std::endl;
+                                )
-                                if ( cvtCost != Cost::infinity ) {
-                                        withFunc->cvtCost = cvtCost;
-                                        candidates.emplace_back( std::move( withFunc ) );
+                                }
+                        }
-                        found = std::move( candidates );
-                        // use a new list so that candidates are not examined by addAnonConversions twice
-                        CandidateList winners = findMinCost( found );
-                        promoteCvtCost( winners );
-                        // function may return a struct/union value, in which case we need to add candidates
-                        // for implicit conversions to each of the anonymous members, which must happen after
-                        // `findMinCost`, since anon conversions are never the cheapest
-                        for ( const CandidateRef & c : winners ) {
-                                addAnonConversions( c );
+                        }
-                        spliceBegin( candidates, winners );
-                        if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
-                                // If resolution is unsuccessful with a target type, try again without, since it
-                                // will sometimes succeed when it wouldn't with a target type binding.
-                                // For example:
-                                //   forall( otype T ) T & ?[]( T *, ptrdiff_t );
-                                //   const char * x = "hello world";
-                                //   unsigned char ch = x[0];
-                                // Fails with simple return type binding (xxx -- check this!) as follows:
-                                // * T is bound to unsigned char
-                                // * (x: const char *) is unified with unsigned char *, which fails
-                                // xxx -- fix this better
-                                targetType = nullptr;
-                                postvisit( untypedExpr );
+                        }
+                }
-                /// true if expression is an lvalue
-                static bool isLvalue( const ast::Expr * x ) {
-                        return x->result && ( x->get_lvalue() || x->result.as< ast::ReferenceType >() );
+                }
-                void postvisit( const ast::AddressExpr * addressExpr ) {
-                        CandidateFinder finder( context, tenv );
-                        finder.find( addressExpr->arg );
-                        if( finder.candidates.empty() ) return;
-                        reason.code = NoMatch;
-                        for ( CandidateRef & r : finder.candidates ) {
-                                if ( ! isLvalue( r->expr ) ) continue;
-                                addCandidate( *r, new ast::AddressExpr{ addressExpr->location, r->expr } );
+                        }
+                }
-                void postvisit( const ast::LabelAddressExpr * labelExpr ) {
-                        addCandidate( labelExpr, tenv );
+                }
-                void postvisit( const ast::CastExpr * castExpr ) {
-                        ast::ptr< ast::Type > toType = castExpr->result;
-                        assert( toType );
-                        toType = resolveTypeof( toType, context );
-                        toType = adjustExprType( toType, tenv, symtab );
-                        CandidateFinder finder( context, tenv, toType );
-                        finder.find( castExpr->arg, ResolvMode::withAdjustment() );
-                        if( !finder.candidates.empty() ) reason.code = NoMatch;
-                        CandidateList matches;
-                        for ( CandidateRef & cand : finder.candidates ) {
-                                ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
-                                ast::OpenVarSet open( cand->open );
-                                cand->env.extractOpenVars( open );
-                                // It is possible that a cast can throw away some values in a multiply-valued
-                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the
-                                // subexpression results that are cast directly. The candidate is invalid if it
-                                // has fewer results than there are types to cast to.
-                                int discardedValues = cand->expr->result->size() - toType->size();
-                                if ( discardedValues < 0 ) continue;
-                                // unification run for side-effects
-                                unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
-                                Cost thisCost =
-                                        (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
-                            ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
-                            : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
-                                PRINT(
-                                        std::cerr << "working on cast with result: " << toType << std::endl;
-                                        std::cerr << "and expr type: " << cand->expr->result << std::endl;
-                                        std::cerr << "env: " << cand->env << std::endl;
+                                )
-                                if ( thisCost != Cost::infinity ) {
-                                        PRINT(
-                                                std::cerr << "has finite cost." << std::endl;
+                                        )
-                                        // count one safe conversion for each value that is thrown away
-                                        thisCost.incSafe( discardedValues );
-                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
-                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost,
-                                                cand->cost + thisCost );
-                                        inferParameters( newCand, matches );
+                                }
+                        }
-                        // select first on argument cost, then conversion cost
-                        CandidateList minArgCost = findMinCost( matches );
-                        promoteCvtCost( minArgCost );
-                        candidates = findMinCost( minArgCost );
+                }
-                void postvisit( const ast::VirtualCastExpr * castExpr ) {
-                        assertf( castExpr->result, "Implicit virtual cast targets not yet supported." );
-                        CandidateFinder finder( context, tenv );
-                        // don't prune here, all alternatives guaranteed to have same type
-                        finder.find( castExpr->arg, ResolvMode::withoutPrune() );
-                        for ( CandidateRef & r : finder.candidates ) {
-                                addCandidate(
-                                        *r,
-                                        new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
+                        }
+                }
-                void postvisit( const ast::KeywordCastExpr * castExpr ) {
-                        const auto & loc = castExpr->location;
-                        assertf( castExpr->result, "Cast target should have been set in Validate." );
-                        auto ref = castExpr->result.strict_as<ast::ReferenceType>();
-                        auto inst = ref->base.strict_as<ast::StructInstType>();
-                        auto target = inst->base.get();
-                        CandidateFinder finder( context, tenv );
-                        auto pick_alternatives = [target, this](CandidateList & found, bool expect_ref) {
-                                for(auto & cand : found) {
-                                        const ast::Type * expr = cand->expr->result.get();
-                                        if(expect_ref) {
-                                                auto res = dynamic_cast<const ast::ReferenceType*>(expr);
-                                                if(!res) { continue; }
-                                                expr = res->base.get();
+                                        }
-                                        if(auto insttype = dynamic_cast<const ast::TypeInstType*>(expr)) {
-                                                auto td = cand->env.lookup(*insttype);
-                                                if(!td) { continue; }
-                                                expr = td->bound.get();
+                                        }
-                                        if(auto base = dynamic_cast<const ast::StructInstType*>(expr)) {
-                                                if(base->base == target) {
-                                                        candidates.push_back( std::move(cand) );
-                                                        reason.code = NoReason;
+                                                }
+                                        }
+                                }
-                        };
-                        try {
-                                // Attempt 1 : turn (thread&)X into (thread$&)X.__thrd
-                                // Clone is purely for memory management
-                                std::unique_ptr<const ast::Expr> tech1 { new ast::UntypedMemberExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.field), castExpr->arg) };
-                                // don't prune here, since it's guaranteed all alternatives will have the same type
-                                finder.find( tech1.get(), ResolvMode::withoutPrune() );
-                                pick_alternatives(finder.candidates, false);
-                                return;
-                        } catch(SemanticErrorException & ) {}
-                        // Fallback : turn (thread&)X into (thread$&)get_thread(X)
-                        std::unique_ptr<const ast::Expr> fallback { ast::UntypedExpr::createDeref(loc,  new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) };
-                        // don't prune here, since it's guaranteed all alternatives will have the same type
-                        finder.find( fallback.get(), ResolvMode::withoutPrune() );
-                        pick_alternatives(finder.candidates, true);
-                        // Whatever happens here, we have no more fallbacks
+                }
-                void postvisit( const ast::UntypedMemberExpr * memberExpr ) {
-                        CandidateFinder aggFinder( context, tenv );
-                        aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
-                        for ( CandidateRef & agg : aggFinder.candidates ) {
-                                // it's okay for the aggregate expression to have reference type -- cast it to the
-                                // base type to treat the aggregate as the referenced value
-                                Cost addedCost = Cost::zero;
-                                agg->expr = referenceToRvalueConversion( agg->expr, addedCost );
-                                // find member of the given type
-                                if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) {
-                                        addAggMembers(
-                                                structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
-                                } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) {
-                                        addAggMembers(
-                                                unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
-                                } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) {
-                                        addTupleMembers( tupleType, agg->expr, *agg, addedCost, memberExpr->member );
+                                }
+                        }
+                }
-                void postvisit( const ast::MemberExpr * memberExpr ) {
-                        addCandidate( memberExpr, tenv );
+                }
-                void postvisit( const ast::NameExpr * nameExpr ) {
-                        std::vector< ast::SymbolTable::IdData > declList;
-                        if (!selfFinder.otypeKeys.empty()) {
-                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
-                                assertf(kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS, "special lookup with non-special target: %s", nameExpr->name.c_str());
-                                for (auto & otypeKey: selfFinder.otypeKeys) {
-                                        auto result = symtab.specialLookupId(kind, otypeKey);
-                                        declList.insert(declList.end(), std::make_move_iterator(result.begin()), std::make_move_iterator(result.end()));
+                                }
+                        }
-                        else {
-                                declList = symtab.lookupId( nameExpr->name );
+                        }
-                        PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
-                        if( declList.empty() ) return;
-                        reason.code = NoMatch;
-                        for ( auto & data : declList ) {
-                                Cost cost = Cost::zero;
-                                ast::Expr * newExpr = data.combine( nameExpr->location, cost );
-                                CandidateRef newCand = std::make_shared<Candidate>(
-                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
-                                        cost );
-                                if (newCand->expr->env) {
-                                        newCand->env.add(*newCand->expr->env);
-                                        auto mutExpr = newCand->expr.get_and_mutate();
-                                        mutExpr->env  = nullptr;
-                                        newCand->expr = mutExpr;
+                                }
-                                PRINT(
-                                        std::cerr << "decl is ";
-                                        ast::print( std::cerr, data.id );
-                                        std::cerr << std::endl;
-                                        std::cerr << "newExpr is ";
-                                        ast::print( std::cerr, newExpr );
-                                        std::cerr << std::endl;
+                                )
-                                newCand->expr = ast::mutate_field(
-                                        newCand->expr.get(), &ast::Expr::result,
-                                        renameTyVars( newCand->expr->result ) );
-                                // add anonymous member interpretations whenever an aggregate value type is seen
-                                // as a name expression
-                                addAnonConversions( newCand );
-                                candidates.emplace_back( std::move( newCand ) );
+                        }
+                }
-                void postvisit( const ast::VariableExpr * variableExpr ) {
-                        // not sufficient to just pass `variableExpr` here, type might have changed since
-                        // creation
-                        addCandidate(
-                                new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
+                }
-                void postvisit( const ast::ConstantExpr * constantExpr ) {
-                        addCandidate( constantExpr, tenv );
+                }
-                void postvisit( const ast::SizeofExpr * sizeofExpr ) {
-                        if ( sizeofExpr->type ) {
-                                addCandidate(
-                                        new ast::SizeofExpr{
-                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
-                                        tenv );
-                        } else {
-                                // find all candidates for the argument to sizeof
-                                CandidateFinder finder( context, tenv );
-                                finder.find( sizeofExpr->expr );
-                                // find the lowest-cost candidate, otherwise ambiguous
-                                CandidateList winners = findMinCost( finder.candidates );
-                                if ( winners.size() != 1 ) {
-                                        SemanticError(
-                                                sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
+                                }
-                                // return the lowest-cost candidate
-                                CandidateRef & choice = winners.front();
-                                choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                                choice->cost = Cost::zero;
-                                addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
+                        }
+                }
-                void postvisit( const ast::AlignofExpr * alignofExpr ) {
-                        if ( alignofExpr->type ) {
-                                addCandidate(
-                                        new ast::AlignofExpr{
-                                                alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
-                                        tenv );
-                        } else {
-                                // find all candidates for the argument to alignof
-                                CandidateFinder finder( context, tenv );
-                                finder.find( alignofExpr->expr );
-                                // find the lowest-cost candidate, otherwise ambiguous
-                                CandidateList winners = findMinCost( finder.candidates );
-                                if ( winners.size() != 1 ) {
-                                        SemanticError(
-                                                alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
+                                }
-                                // return the lowest-cost candidate
-                                CandidateRef & choice = winners.front();
-                                choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                                choice->cost = Cost::zero;
-                                addCandidate(
-                                        *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
+                        }
+                }
-                void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
-                        const ast::BaseInstType * aggInst;
-                        if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
-                        else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;
-                        else return;
-                        for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
-                                auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
-                                addCandidate(
-                                        new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
+                        }
+                }
-                void postvisit( const ast::OffsetofExpr * offsetofExpr ) {
-                        addCandidate( offsetofExpr, tenv );
+                }
-                void postvisit( const ast::OffsetPackExpr * offsetPackExpr ) {
-                        addCandidate( offsetPackExpr, tenv );
+                }
-                void postvisit( const ast::LogicalExpr * logicalExpr ) {
-                        CandidateFinder finder1( context, tenv );
-                        finder1.find( logicalExpr->arg1, ResolvMode::withAdjustment() );
-                        if ( finder1.candidates.empty() ) return;
-                        CandidateFinder finder2( context, tenv );
-                        finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() );
-                        if ( finder2.candidates.empty() ) return;
-                        reason.code = NoMatch;
-                        for ( const CandidateRef & r1 : finder1.candidates ) {
-                                for ( const CandidateRef & r2 : finder2.candidates ) {
-                                        ast::TypeEnvironment env{ r1->env };
-                                        env.simpleCombine( r2->env );
-                                        ast::OpenVarSet open{ r1->open };
-                                        mergeOpenVars( open, r2->open );
-                                        ast::AssertionSet need;
-                                        mergeAssertionSet( need, r1->need );
-                                        mergeAssertionSet( need, r2->need );
-                                        addCandidate(
-                                                new ast::LogicalExpr{
-                                                        logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd },
-                                                std::move( env ), std::move( open ), std::move( need ), r1->cost + r2->cost );
+                                }
+                        }
+                }
-                void postvisit( const ast::ConditionalExpr * conditionalExpr ) {
-                        // candidates for condition
-                        CandidateFinder finder1( context, tenv );
-                        finder1.find( conditionalExpr->arg1, ResolvMode::withAdjustment() );
-                        if ( finder1.candidates.empty() ) return;
-                        // candidates for true result
-                        CandidateFinder finder2( context, tenv );
-                        finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
-                        if ( finder2.candidates.empty() ) return;
-                        // candidates for false result
-                        CandidateFinder finder3( context, tenv );
-                        finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
-                        if ( finder3.candidates.empty() ) return;
-                        reason.code = NoMatch;
-                        for ( const CandidateRef & r1 : finder1.candidates ) {
-                                for ( const CandidateRef & r2 : finder2.candidates ) {
-                                        for ( const CandidateRef & r3 : finder3.candidates ) {
-                                                ast::TypeEnvironment env{ r1->env };
-                                                env.simpleCombine( r2->env );
-                                                env.simpleCombine( r3->env );
-                                                ast::OpenVarSet open{ r1->open };
-                                                mergeOpenVars( open, r2->open );
-                                                mergeOpenVars( open, r3->open );
-                                                ast::AssertionSet need;
-                                                mergeAssertionSet( need, r1->need );
-                                                mergeAssertionSet( need, r2->need );
-                                                mergeAssertionSet( need, r3->need );
-                                                ast::AssertionSet have;
-                                                // unify true and false results, then infer parameters to produce new
-                                                // candidates
-                                                ast::ptr< ast::Type > common;
-                                                if (
-                                                        unify(
-                                                                r2->expr->result, r3->expr->result, env, need, have, open, symtab,
-                                                                common )
-                                                ) {
-                                                        // generate typed expression
-                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{
-                                                                conditionalExpr->location, r1->expr, r2->expr, r3->expr };
-                                                        newExpr->result = common ? common : r2->expr->result;
-                                                        // convert both options to result type
-                                                        Cost cost = r1->cost + r2->cost + r3->cost;
-                                                        newExpr->arg2 = computeExpressionConversionCost(
-                                                                newExpr->arg2, newExpr->result, symtab, env, cost );
-                                                        newExpr->arg3 = computeExpressionConversionCost(
-                                                                newExpr->arg3, newExpr->result, symtab, env, cost );
-                                                        // output candidate
-                                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                                newExpr, std::move( env ), std::move( open ), std::move( need ), cost );
-                                                        inferParameters( newCand, candidates );
+                                                }
+                                        }
+                                }
+                        }
+                }
-                void postvisit( const ast::CommaExpr * commaExpr ) {
-                        ast::TypeEnvironment env{ tenv };
-                        ast::ptr< ast::Expr > arg1 = resolveInVoidContext( commaExpr->arg1, context, env );
-                        CandidateFinder finder2( context, env );
-                        finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
-                        for ( const CandidateRef & r2 : finder2.candidates ) {
-                                addCandidate( *r2, new ast::CommaExpr{ commaExpr->location, arg1, r2->expr } );
+                        }
+                }
-                void postvisit( const ast::ImplicitCopyCtorExpr * ctorExpr ) {
-                        addCandidate( ctorExpr, tenv );
+                }
-                void postvisit( const ast::ConstructorExpr * ctorExpr ) {
-                        CandidateFinder finder( context, tenv );
-                        finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
-                        for ( CandidateRef & r : finder.candidates ) {
-                                addCandidate( *r, new ast::ConstructorExpr{ ctorExpr->location, r->expr } );
+                        }
+                }
-                void postvisit( const ast::RangeExpr * rangeExpr ) {
-                        // resolve low and high, accept candidates where low and high types unify
-                        CandidateFinder finder1( context, tenv );
-                        finder1.find( rangeExpr->low, ResolvMode::withAdjustment() );
-                        if ( finder1.candidates.empty() ) return;
-                        CandidateFinder finder2( context, tenv );
-                        finder2.find( rangeExpr->high, ResolvMode::withAdjustment() );
-                        if ( finder2.candidates.empty() ) return;
-                        reason.code = NoMatch;
-                        for ( const CandidateRef & r1 : finder1.candidates ) {
-                                for ( const CandidateRef & r2 : finder2.candidates ) {
-                                        ast::TypeEnvironment env{ r1->env };
-                                        env.simpleCombine( r2->env );
-                                        ast::OpenVarSet open{ r1->open };
-                                        mergeOpenVars( open, r2->open );
-                                        ast::AssertionSet need;
-                                        mergeAssertionSet( need, r1->need );
-                                        mergeAssertionSet( need, r2->need );
-                                        ast::AssertionSet have;
-                                        ast::ptr< ast::Type > common;
-                                        if (
-                                                unify(
-                                                        r1->expr->result, r2->expr->result, env, need, have, open, symtab,
-                                                        common )
-                                        ) {
-                                                // generate new expression
-                                                ast::RangeExpr * newExpr =
-                                                        new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr };
-                                                newExpr->result = common ? common : r1->expr->result;
-                                                // add candidate
-                                                CandidateRef newCand = std::make_shared<Candidate>(
-                                                        newExpr, std::move( env ), std::move( open ), std::move( need ),
-                                                        r1->cost + r2->cost );
-                                                inferParameters( newCand, candidates );
+                                        }
+                                }
+                        }
+                }
-                void postvisit( const ast::UntypedTupleExpr * tupleExpr ) {
-                        std::vector< CandidateFinder > subCandidates =
-                                selfFinder.findSubExprs( tupleExpr->exprs );
-                        std::vector< CandidateList > possibilities;
-                        combos( subCandidates.begin(), subCandidates.end(), back_inserter( possibilities ) );
-                        for ( const CandidateList & subs : possibilities ) {
-                                std::vector< ast::ptr< ast::Expr > > exprs;
-                                exprs.reserve( subs.size() );
-                                for ( const CandidateRef & sub : subs ) { exprs.emplace_back( sub->expr ); }
-                                ast::TypeEnvironment env;
-                                ast::OpenVarSet open;
-                                ast::AssertionSet need;
-                                for ( const CandidateRef & sub : subs ) {
-                                        env.simpleCombine( sub->env );
-                                        mergeOpenVars( open, sub->open );
-                                        mergeAssertionSet( need, sub->need );
+                                }
-                                addCandidate(
-                                        new ast::TupleExpr{ tupleExpr->location, std::move( exprs ) },
-                                        std::move( env ), std::move( open ), std::move( need ), sumCost( subs ) );
+                        }
+                }
-                void postvisit( const ast::TupleExpr * tupleExpr ) {
-                        addCandidate( tupleExpr, tenv );
+                }
-                void postvisit( const ast::TupleIndexExpr * tupleExpr ) {
-                        addCandidate( tupleExpr, tenv );
+                }
-                void postvisit( const ast::TupleAssignExpr * tupleExpr ) {
-                        addCandidate( tupleExpr, tenv );
+                }
-                void postvisit( const ast::UniqueExpr * unqExpr ) {
-                        CandidateFinder finder( context, tenv );
-                        finder.find( unqExpr->expr, ResolvMode::withAdjustment() );
-                        for ( CandidateRef & r : finder.candidates ) {
-                                // ensure that the the id is passed on so that the expressions are "linked"
-                                addCandidate( *r, new ast::UniqueExpr{ unqExpr->location, r->expr, unqExpr->id } );
+                        }
+                }
-                void postvisit( const ast::StmtExpr * stmtExpr ) {
-                        addCandidate( resolveStmtExpr( stmtExpr, context ), tenv );
+                }
-                void postvisit( const ast::UntypedInitExpr * initExpr ) {
-                        // handle each option like a cast
-                        CandidateList matches;
-                        PRINT(
-                                std::cerr << "untyped init expr: " << initExpr << std::endl;
+                        )
-                        // O(n^2) checks of d-types with e-types
-                        for ( const ast::InitAlternative & initAlt : initExpr->initAlts ) {
-                                // calculate target type
-                                const ast::Type * toType = resolveTypeof( initAlt.type, context );
-                                toType = adjustExprType( toType, tenv, symtab );
-                                // The call to find must occur inside this loop, otherwise polymorphic return
-                                // types are not bound to the initialization type, since return type variables are
-                                // only open for the duration of resolving the UntypedExpr.
-                                CandidateFinder finder( context, tenv, toType );
-                                finder.find( initExpr->expr, ResolvMode::withAdjustment() );
-                                for ( CandidateRef & cand : finder.candidates ) {
-                                        if(reason.code == NotFound) reason.code = NoMatch;
-                                        ast::TypeEnvironment env{ cand->env };
-                                        ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
-                                        ast::OpenVarSet open{ cand->open };
-                                        PRINT(
-                                                std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
+                                        )
-                                        // It is possible that a cast can throw away some values in a multiply-valued
-                                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of
-                                        // the subexpression results that are cast directly. The candidate is invalid
-                                        // if it has fewer results than there are types to cast to.
-                                        int discardedValues = cand->expr->result->size() - toType->size();
-                                        if ( discardedValues < 0 ) continue;
-                                        // unification run for side-effects
-                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
-                                        (void) canUnify;
-                                        Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                symtab, env );
-                                        PRINT(
-                                                Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                        symtab, env );
-                                                std::cerr << "Considering initialization:";
-                                                std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
-                                                std::cerr << std::endl << "  TO: "   << toType             << std::endl;
-                                                std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
-                                                std::cerr << std::endl << "  Legacy cost " << legacyCost;
-                                                std::cerr << std::endl << "  New cost " << thisCost;
-                                                std::cerr << std::endl;
+                                        )
-                                        if ( thisCost != Cost::infinity ) {
-                                                // count one safe conversion for each value that is thrown away
-                                                thisCost.incSafe( discardedValues );
-                                                CandidateRef newCand = std::make_shared<Candidate>(
-                                                        new ast::InitExpr{
-                                                                initExpr->location, restructureCast( cand->expr, toType ),
-                                                                initAlt.designation },
-                                                        std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost );
-                                                inferParameters( newCand, matches );
+                                        }
+                                }
+                        }
-                        // select first on argument cost, then conversion cost
-                        CandidateList minArgCost = findMinCost( matches );
-                        promoteCvtCost( minArgCost );
-                        candidates = findMinCost( minArgCost );
+                }
-                void postvisit( const ast::InitExpr * ) {
-                        assertf( false, "CandidateFinder should never see a resolved InitExpr." );
+                }
-                void postvisit( const ast::DeletedExpr * ) {
-                        assertf( false, "CandidateFinder should never see a DeletedExpr." );
+                }
-                void postvisit( const ast::GenericExpr * ) {
-                        assertf( false, "_Generic is not yet supported." );
+                }
-        };
-        // size_t Finder::traceId = Stats::Heap::new_stacktrace_id("Finder");
-        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
-        /// return type. Skips ambiguous candidates.
-} // anonymous namespace
-bool CandidateFinder::pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector<std::string> & errors ) {
-        struct PruneStruct {
-                CandidateRef candidate;
-                bool ambiguous;
-                PruneStruct() = default;
-                PruneStruct( const CandidateRef & c ) : candidate( c ), ambiguous( false ) {}
-        };
-        // find lowest-cost candidate for each type
-        std::unordered_map< std::string, PruneStruct > selected;
-        // attempt to skip satisfyAssertions on more expensive alternatives if better options have been found
-        std::sort(candidates.begin(), candidates.end(), [](const CandidateRef & x, const CandidateRef & y){return x->cost < y->cost;});
-        for ( CandidateRef & candidate : candidates ) {
-                std::string mangleName;
+                {
-                        ast::ptr< ast::Type > newType = candidate->expr->result;
-                        assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
-                        candidate->env.apply( newType );
-                        mangleName = Mangle::mangle( newType );
+                }
-                auto found = selected.find( mangleName );
-                if (found != selected.end() && found->second.candidate->cost < candidate->cost) {
-                        PRINT(
-                                std::cerr << "cost " << candidate->cost << " loses to "
-                                        << found->second.candidate->cost << std::endl;
+                        )
-                        continue;
+                }
-                // xxx - when do satisfyAssertions produce more than 1 result?
-                // this should only happen when initial result type contains
-                // unbound type parameters, then it should never be pruned by
-                // the previous step, since renameTyVars guarantees the mangled name
-                // is unique.
-                CandidateList satisfied;
-                bool needRecomputeKey = false;
-                if (candidate->need.empty()) {
-                        satisfied.emplace_back(candidate);
+                }
-                else {
-                        satisfyAssertions(candidate, context.symtab, satisfied, errors);
-                        needRecomputeKey = true;
+                }
-                for (auto & newCand : satisfied) {
-                        // recomputes type key, if satisfyAssertions changed it
-                        if (needRecomputeKey)
+                        {
-                                ast::ptr< ast::Type > newType = newCand->expr->result;
-                                assertf(newCand->expr->result, "Result of expression %p for candidate is null", newCand->expr.get());
-                                newCand->env.apply( newType );
-                                mangleName = Mangle::mangle( newType );
+                        }
-                        auto found = selected.find( mangleName );
-                        if ( found != selected.end() ) {
-                                if ( newCand->cost < found->second.candidate->cost ) {
-                                        PRINT(
-                                                std::cerr << "cost " << newCand->cost << " beats "
-                                                        << found->second.candidate->cost << std::endl;
+                                        )
-                                        found->second = PruneStruct{ newCand };
-                                } else if ( newCand->cost == found->second.candidate->cost ) {
-                                        // if one of the candidates contains a deleted identifier, can pick the other,
-                                        // since deleted expressions should not be ambiguous if there is another option
-                                        // that is at least as good
-                                        if ( findDeletedExpr( newCand->expr ) ) {
-                                                // do nothing
-                                                PRINT( std::cerr << "candidate is deleted" << std::endl; )
-                                        } else if ( findDeletedExpr( found->second.candidate->expr ) ) {
-                                                PRINT( std::cerr << "current is deleted" << std::endl; )
-                                                found->second = PruneStruct{ newCand };
-                                        } else {
-                                                PRINT( std::cerr << "marking ambiguous" << std::endl; )
-                                                found->second.ambiguous = true;
+                                        }
-                                } else {
-                                        // xxx - can satisfyAssertions increase the cost?
-                                        PRINT(
-                                                std::cerr << "cost " << newCand->cost << " loses to "
-                                                        << found->second.candidate->cost << std::endl;
+                                        )
+                                }
-                        } else {
-                                selected.emplace_hint( found, mangleName, newCand );
+                        }
+                }
+        }
-        // report unambiguous min-cost candidates
-        // CandidateList out;
-        for ( auto & target : selected ) {
-                if ( target.second.ambiguous ) continue;
-                CandidateRef cand = target.second.candidate;
-                ast::ptr< ast::Type > newResult = cand->expr->result;
-                cand->env.applyFree( newResult );
-                cand->expr = ast::mutate_field(
-                        cand->expr.get(), &ast::Expr::result, std::move( newResult ) );
-                out.emplace_back( cand );
+        }
-        // if everything is lost in satisfyAssertions, report the error
-        return !selected.empty();
+}
-void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
-        // Find alternatives for expression
-        ast::Pass<Finder> finder{ *this };
-        expr->accept( finder );
-        if ( mode.failFast && candidates.empty() ) {
-                switch(finder.core.reason.code) {
-                case Finder::NotFound:
-                        { SemanticError( expr, "No alternatives for expression " ); break; }
-                case Finder::NoMatch:
-                        { SemanticError( expr, "Invalid application of existing declaration(s) in expression " ); break; }
-                case Finder::ArgsToFew:
-                case Finder::ArgsToMany:
-                case Finder::RetsToFew:
-                case Finder::RetsToMany:
-                case Finder::NoReason:
-                default:
-                        { SemanticError( expr->location, "No reasonable alternatives for expression : reasons unkown" ); }
+                }
+        }
-        /*
-        if ( mode.satisfyAssns || mode.prune ) {
-                // trim candidates to just those where the assertions are satisfiable
-                // - necessary pre-requisite to pruning
-                CandidateList satisfied;
-                std::vector< std::string > errors;
-                for ( CandidateRef & candidate : candidates ) {
-                        satisfyAssertions( candidate, localSyms, satisfied, errors );
+                }
-                // fail early if none such
-                if ( mode.failFast && satisfied.empty() ) {
-                        std::ostringstream stream;
-                        stream << "No alternatives with satisfiable assertions for " << expr << "\n";
-                        for ( const auto& err : errors ) {
-                                stream << err;
+                        }
-                        SemanticError( expr->location, stream.str() );
+                }
-                // reset candidates
-                candidates = move( satisfied );
+        }
-        */
-        if ( mode.prune ) {
-                // trim candidates to single best one
-                PRINT(
-                        std::cerr << "alternatives before prune:" << std::endl;
-                        print( std::cerr, candidates );
+                )
-                CandidateList pruned;
-                std::vector<std::string> errors;
-                bool found = pruneCandidates( candidates, pruned, errors );
-                if ( mode.failFast && pruned.empty() ) {
-                        std::ostringstream stream;
-                        if (found) {
-                                CandidateList winners = findMinCost( candidates );
-                                stream << "Cannot choose between " << winners.size() << " alternatives for "
-                                        "expression\n";
-                                ast::print( stream, expr );
-                                stream << " Alternatives are:\n";
-                                print( stream, winners, 1 );
-                                SemanticError( expr->location, stream.str() );
+                        }
-                        else {
-                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
-                                for ( const auto& err : errors ) {
-                                        stream << err;
+                                }
-                                SemanticError( expr->location, stream.str() );
+                        }
+                }
-                auto oldsize = candidates.size();
-                candidates = std::move( pruned );
-                PRINT(
-                        std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
+                )
-                PRINT(
-                        std::cerr << "there are " << candidates.size() << " alternatives after elimination"
-                                << std::endl;
+                )
+        }
-        // adjust types after pruning so that types substituted by pruneAlternatives are correctly
-        // adjusted
-        if ( mode.adjust ) {
-                for ( CandidateRef & r : candidates ) {
-                        r->expr = ast::mutate_field(
-                                r->expr.get(), &ast::Expr::result,
-                                adjustExprType( r->expr->result, r->env, context.symtab ) );
+                }
+        }
-        // Central location to handle gcc extension keyword, etc. for all expressions
-        for ( CandidateRef & r : candidates ) {
-                if ( r->expr->extension != expr->extension ) {
-                        r->expr.get_and_mutate()->extension = expr->extension;
+                }
+        }
+}
-std::vector< CandidateFinder > CandidateFinder::findSubExprs(
-        const std::vector< ast::ptr< ast::Expr > > & xs
-) {
-        std::vector< CandidateFinder > out;
-        for ( const auto & x : xs ) {
-                out.emplace_back( context, env );
-                out.back().find( x, ResolvMode::withAdjustment() );
-                PRINT(
-                        std::cerr << "findSubExprs" << std::endl;
-                        print( std::cerr, out.back().candidates );
+                )
+        }
-        return out;
+}
 } // namespace ResolvExpr

src/ResolvExpr/CurrentObject.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Rob Schluntz
 // Created On       : Tue Jun 13 15:28:32 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul  1 09:16:01 2022
 // Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr 10  9:40:00 2023
+// Update Count     : 18
 //
 …
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
 #include "AST/Print.hpp"                // for readonly
+#include "AST/Print.hpp"               // for readonly
 #include "AST/Type.hpp"
+#include "Common/Eval.h"               // for eval
 #include "Common/Indenter.h"           // for Indenter, operator<<
 #include "Common/SemanticError.h"      // for SemanticError
 …
 namespace ast {
+        /// Iterates members of a type by initializer.
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+                /// Internal set position based on iterator ranges.
+                virtual void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator it,
+                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
+                /// Walks the current object using the given designators as a guide.
+                void setPosition( const std::deque< ptr< Expr > > & designators ) {
+                        setPosition( designators.begin(), designators.end() );
+                }
+                /// Retrieve the list of possible (Type,Designation) pairs for the
+                /// current position in the current object.
+                virtual std::deque< InitAlternative > operator* () const = 0;
+                /// True if the iterator is not currently at the end.
+                virtual operator bool() const = 0;
+                /// Moves the iterator by one member in the current object.
+                virtual MemberIterator & bigStep() = 0;
+                /// Moves the iterator by one member in the current subobject.
+                virtual MemberIterator & smallStep() = 0;
+                /// The type of the current object.
+                virtual const Type * getType() = 0;
+                /// The type of the current subobject.
+                virtual const Type * getNext() = 0;
+                /// Helper for operator*; aggregates must add designator to each init
+                /// alternative, but adding designators in operator* creates duplicates.
+                virtual std::deque< InitAlternative > first() const = 0;
+        };
         /// create a new MemberIterator that traverses a type correctly
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type );
 …
         };
+        /// Iterates array types
+        class ArrayIterator final : public MemberIterator {
+        /// Iterates over an indexed type:
+        class IndexIterator : public MemberIterator {
+        protected:
                 CodeLocation location;
-                const ArrayType * array = nullptr;
-                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;
+                std::unique_ptr< MemberIterator > memberIter;
+                void setSize( const Expr * expr ) {
+                        auto res = eval( expr );
+                        if ( ! res.second ) {
+                                SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
+                        }
+                        size = res.first;
+                }
+        public:
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) : location( loc ), array( at ), base( at->base ) {
+                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, base ) );
+                        if ( at->isVarLen ) {
+                                SemanticError( location, at, "VLA initialization does not support @=: " );
+                        }
+                        setSize( at->dimension );
+                }
+                std::unique_ptr<MemberIterator> memberIter;
+        public:
+                IndexIterator( const CodeLocation & loc, size_t size ) :
+                        location( loc ), size( size )
+                {}
                 void setPosition( const Expr * expr ) {
 …
                         auto arg = eval( expr );
                         index = arg.first;
-                        return;
                         // if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
 …
                 void setPosition(
                         std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
+                        std::deque<ast::ptr<ast::Expr>>::const_iterator begin,
+                        std::deque<ast::ptr<ast::Expr>>::const_iterator end
                 ) override {
                         if ( begin == end ) return;
 …
                 operator bool() const override { return index < size; }
+        };
+        /// Iterates over the members of array types:
+        class ArrayIterator final : public IndexIterator {
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
+                size_t getSize( const Expr * expr ) {
+                        auto res = eval( expr );
+                        if ( !res.second ) {
+                                SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
+                        }
+                        return res.first;
+                }
+        public:
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) :
+                                IndexIterator( loc, getSize( at->dimension) ),
+                                array( at ), base( at->base ) {
+                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, base ) );
+                        if ( at->isVarLen ) {
+                                SemanticError( location, at, "VLA initialization does not support @=: " );
+                        }
+                }
                 ArrayIterator & bigStep() override {
 …
                 const Type * getNext() final {
+                        return ( memberIter && *memberIter ) ? memberIter->getType() : nullptr;
+                        bool hasMember = memberIter && *memberIter;
+                        return hasMember ? memberIter->getType() : nullptr;
+                }
 …
         };
+        class TupleIterator final : public AggregateIterator {
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * inst )
+                : AggregateIterator(
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
+                ) {}
+                operator bool() const override {
+                        return curMember != members.end() || (memberIter && *memberIter);
+        /// Iterates across the positions in a tuple:
+        class TupleIterator final : public IndexIterator {
+                ast::TupleType const * const tuple;
+                const ast::Type * typeAtIndex() const {
+                        assert( index < size );
+                        return tuple->types[ index ].get();
+                }
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * type )
+                : IndexIterator( loc, type->size() ), tuple( type ) {
+                        PRINT( std::cerr << "Creating tuple iterator: " << type << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, typeAtIndex() ) );
+                }
                 TupleIterator & bigStep() override {
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        while ( curMember != members.end() ) {
+                                ++curMember;
+                                if ( init() ) return *this;
+                        }
+                        ++index;
+                        memberIter.reset( index < size ?
+                                createMemberIterator( location, typeAtIndex() ) : nullptr );
                         return *this;
+                }
+                TupleIterator & smallStep() override {
+                        if ( memberIter ) {
+                                PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; )
+                                memberIter->smallStep();
+                                if ( !memberIter ) {
+                                        PRINT( std::cerr << "has valid member iter" << std::endl; )
+                                        return *this;
+                                }
+                        }
+                        return bigStep();
+                }
+                const ast::Type * getType() override {
+                        return tuple;
+                }
+                const ast::Type * getNext() override {
+                        bool hasMember = memberIter && *memberIter;
+                        return hasMember ? memberIter->getType() : nullptr;
+                }
+                std::deque< InitAlternative > first() const override {
+                        PRINT( std::cerr << "first in TupleIterator (" << index << "/" << size << ")" << std::endl; )
+                        if ( memberIter && *memberIter ) {
+                                std::deque< InitAlternative > ret = memberIter->first();
+                                for ( InitAlternative & alt : ret ) {
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
+                                                ConstantExpr::from_ulong( location, index ) );
+                                }
+                                return ret;
+                        }
+                        return {};
+                }
         };

src/ResolvExpr/CurrentObject.h

-              r2ed94a9
+              rb110bcc
 // Author           : Rob Schluntz
 // Created On       : Thu Jun  8 11:07:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:48 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Apr  6 16:14:00 2023
+// Update Count     : 4
 //
 …
         /// Iterates members of a type by initializer
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+                /// Internal set position based on iterator ranges
+                virtual void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator it,
+                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
+                /// walks the current object using the given designators as a guide
+                void setPosition( const std::deque< ptr< Expr > > & designators ) {
+                        setPosition( designators.begin(), designators.end() );
+                }
+                /// retrieve the list of possible (Type,Designation) pairs for the current position in the
+                /// current object
+                virtual std::deque< InitAlternative > operator* () const = 0;
+                /// true if the iterator is not currently at the end
+                virtual operator bool() const = 0;
+                /// moves the iterator by one member in the current object
+                virtual MemberIterator & bigStep() = 0;
+                /// moves the iterator by one member in the current subobject
+                virtual MemberIterator & smallStep() = 0;
+                /// the type of the current object
+                virtual const Type * getType() = 0;
+                /// the type of the current subobject
+                virtual const Type * getNext() = 0;
+                /// helper for operator*; aggregates must add designator to each init alternative, but
+                /// adding designators in operator* creates duplicates
+                virtual std::deque< InitAlternative > first() const = 0;
+        };
+        class MemberIterator;
         /// Builds initializer lists in resolution

src/ResolvExpr/ExplodedArg.hpp

r2ed94a9	rb110bcc
35	35	ExplodedArg() : env(), cost( Cost::zero ), exprs() {}
36	36	ExplodedArg( const Candidate & arg, const ast::SymbolTable & symtab );
37
	37
38	38	ExplodedArg( ExplodedArg && ) = default;
39	39	ExplodedArg & operator= ( ExplodedArg && ) = default;

src/ResolvExpr/ResolveAssertions.cc

r2ed94a9	rb110bcc
30	30	#include "Common/FilterCombos.h" // for filterCombos
31	31	#include "Common/Indenter.h" // for Indenter
32		~~#include "Common/utility.h" // for sort_mins~~
33	32	#include "GenPoly/GenPoly.h" // for getFunctionType
34	33	#include "ResolvExpr/AlternativeFinder.h" // for computeConversionCost

src/ResolvExpr/Resolver.cc

-              r2ed94a9
+              rb110bcc
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "Common/Eval.h"                 // for eval
+#include "Common/Iterate.hpp"            // for group_iterate
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
+#include "Common/ToString.hpp"           // for toCString
 #include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt

src/ResolvExpr/Resolver.h

r2ed94a9	rb110bcc
34	34	class Decl;
35	35	class DeletedExpr;
	36	class Expr;
36	37	class Init;
37	38	class StmtExpr;

src/SymTab/Autogen.cc

-              r2ed94a9
+              rb110bcc
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr 27 14:39:06 2018
 // Update Count     : 63
+// Last Modified On : Fri Apr 14 15:03:00 2023
+// Update Count     : 64
 //
 …
+        }
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
-                return obj && obj->name.empty() && obj->bitfieldWidth;
+        }
         /// inserts a forward declaration for functionDecl into declsToAdd
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
 …
+        }
-        // shallow copy the pointer list for return
-        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
-                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
-                        return structInst->base->params;
+                }
-                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
-                        return unionInst->base->params;
+                }
-                return {};
+        }
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
 …
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
-        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
-        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
-                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
-                if (maybePolymorphic) typeParams = getGenericParams(paramType);
-                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
-                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc), {}, ast::Linkage::Cforall);
+        }

src/SymTab/Autogen.h

-              r2ed94a9
+              rb110bcc
 // Author           : Rob Schluntz
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 16:38:06 2019
 // Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Apr 14 15:06:00 2023
+// Update Count     : 17
 //
 …
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
         /// generate the type of an assignment function for paramType.
 …
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
-        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
         /// generate the type of a copy constructor for paramType.
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
 …
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
 …
                 *out++ = new ExprStmt( fExpr );
-                srcParam.clearArrayIndices();
-                return listInit;
+        }
-        /// inserts into out a generated call expression to function fname with arguments dstParam and
-        /// srcParam. Should only be called with non-array types.
-        /// optionally returns a statement which must be inserted prior to the containing loop, if
-        /// there is one
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genScalarCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
-                const ast::Type * addCast = nullptr
-        ) {
-                bool isReferenceCtorDtor = false;
-                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
-                        // reference constructors are essentially application of the rebind operator.
-                        // apply & to both arguments, do not need a cast
-                        fname = "?=?";
-                        dstParam = new ast::AddressExpr{ dstParam };
-                        addCast = nullptr;
-                        isReferenceCtorDtor = true;
+                }
-                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
-                // "?=?", "?{}", or "^?{}"
-                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
-                if ( addCast ) {
-                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
-                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
-                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
-                        // lvalue-qualified type, so remove all qualifiers except lvalue.
-                        // xxx -- old code actually removed lvalue too...
-                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
-                        ast::ptr< ast::Type > castType = addCast;
-                        ast::remove_qualifiers(
-                                castType,
-                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
-                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
+                }
-                fExpr->args.emplace_back( dstParam );
-                ast::ptr<ast::Stmt> listInit = srcParam.buildListInit( fExpr );
-                // fetch next set of arguments
-                ++srcParam;
-                // return if adding reference fails -- will happen on default ctor and dtor
-                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
-                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
-                splice( fExpr->args, args );
-                *out++ = new ast::ExprStmt{ loc, fExpr };
                 srcParam.clearArrayIndices();
 …
+        }
-        /// Store in out a loop which calls fname on each element of the array with srcParam and
-        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
-        template< typename OutIter >
-        void genArrayCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::ArrayType * array, const ast::Type * addCast = nullptr,
-                LoopDirection forward = LoopForward
-        ) {
-                static UniqueName indexName( "_index" );
-                // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->dimension ) return;
-                if ( addCast ) {
-                        // peel off array layer from cast
-                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
+                }
-                ast::ptr< ast::Expr > begin, end;
-                std::string cmp, update;
-                if ( forward ) {
-                        // generate: for ( int i = 0; i < N; ++i )
-                        begin = ast::ConstantExpr::from_int( loc, 0 );
-                        end = array->dimension;
-                        cmp = "?<?";
-                        update = "++?";
-                } else {
-                        // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = ast::UntypedExpr::createCall( loc, "?-?",
-                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } );
-                        end = ast::ConstantExpr::from_int( loc, 0 );
-                        cmp = "?>=?";
-                        update = "--?";
+                }
-                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{
-                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
-                        new ast::SingleInit{ loc, begin } };
-                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
-                ast::ptr< ast::Expr > cond = ast::UntypedExpr::createCall(
-                        loc, cmp, { indexVar, end } );
-                ast::ptr< ast::Expr > inc = ast::UntypedExpr::createCall(
-                        loc, update, { indexVar } );
-                ast::ptr< ast::Expr > dstIndex = ast::UntypedExpr::createCall(
-                        loc, "?[?]", { dstParam, indexVar } );
-                // srcParam must keep track of the array indices to build the source parameter and/or
-                // array list initializer
-                srcParam.addArrayIndex( indexVar, array->dimension );
-                // for stmt's body, eventually containing call
-                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
-                ast::ptr< ast::Stmt > listInit = genCall(
-                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast,
-                        forward );
-                // block containing the stmt and index variable
-                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
-                block->push_back( new ast::DeclStmt{ loc, index } );
-                if ( listInit ) { block->push_back( listInit ); }
-                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
-                *out++ = block;
+        }
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
 …
                 } else {
                         return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                }
+        }
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
-        ) {
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        genArrayCall(
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast,
-                                forward );
-                        return {};
-                } else {
-                        return genScalarCall(
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
+                }
+        }
 …
+        }
-        static inline ast::ptr< ast::Stmt > genImplicitCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
-                LoopDirection forward = LoopForward
-        ) {
-                // unnamed bit fields are not copied as they cannot be accessed
-                if ( isUnnamedBitfield( obj ) ) return {};
-                ast::ptr< ast::Type > addCast;
-                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
-                        assert( dstParam->result );
-                        addCast = dstParam->result;
+                }
-                std::vector< ast::ptr< ast::Stmt > > stmts;
-                genCall(
-                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
-                if ( stmts.empty() ) {
-                        return {};
-                } else if ( stmts.size() == 1 ) {
-                        const ast::Stmt * callStmt = stmts.front();
-                        if ( addCast ) {
-                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
-                                // aware they were generated.
-                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
+                        }
-                        return callStmt;
-                } else {
-                        assert( false );
-                        return {};
+                }
+        }
 } // namespace SymTab

src/SymTab/FixFunction.cc

r2ed94a9	rb110bcc
21	21	#include "AST/Pass.hpp"
22	22	#include "AST/Type.hpp"
23		#include "Common/utility.h" // for ~~maybeClone,~~ copy
	23	#include "Common/utility.h" // for copy
24	24	#include "SynTree/Declaration.h" // for FunctionDecl, ObjectDecl, Declarati...
25	25	#include "SynTree/Expression.h" // for Expression

src/SymTab/Mangler.cc

-              r2ed94a9
+              rb110bcc
 #include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
 #include "Common/PassVisitor.h"
+#include "Common/ToString.hpp"           // for toCString
 #include "Common/SemanticError.h"        // for SemanticError
-#include "Common/utility.h"              // for toString
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
 #include "SynTree/LinkageSpec.h"         // for Spec, isOverridable, AutoGen, Int...

src/SymTab/Validate.cc

-              r2ed94a9
+              rb110bcc
 #include "Common/ScopedMap.h"          // for ScopedMap
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for operator+, cloneAll, deleteAll
+#include "Common/utility.h"            // for cloneAll, deleteAll
 #include "CompilationState.h"          // skip some passes in new-ast build
 #include "Concurrency/Keywords.h"      // for applyKeywords

src/SymTab/ValidateType.cc

r2ed94a9	rb110bcc
18	18	#include "CodeGen/OperatorTable.h"
19	19	#include "Common/PassVisitor.h"
	20	#include "Common/ToString.hpp"
20	21	#include "SymTab/FixFunction.h"
21	22	#include "SynTree/Declaration.h"

src/SymTab/module.mk

r2ed94a9	rb110bcc
20	20	SymTab/FixFunction.cc \
21	21	SymTab/FixFunction.h \
	22	SymTab/GenImplicitCall.cpp \
	23	SymTab/GenImplicitCall.hpp \
22	24	SymTab/Indexer.cc \
23	25	SymTab/Indexer.h \

src/SynTree/AggregateDecl.cc

r2ed94a9	rb110bcc
19	19
20	20	#include "Attribute.h" // for Attribute
	21	#include "Common/Eval.h" // for eval
21	22	#include "Common/utility.h" // for printAll, cloneAll, deleteAll
22	23	#include "Declaration.h" // for AggregateDecl, TypeDecl, Declaration

src/SynTree/FunctionDecl.cc

-              r2ed94a9
+              rb110bcc
         } // if
+        if ( !withExprs.empty() ) {
+                os << indent << "... with clause" << std::endl;
+                os << indent + 1;
+                printAll( withExprs, os, indent + 1 );
+        }
         if ( statements ) {
                 os << indent << "... with body" << endl << indent+1;

src/SynTree/Type.cc

-              r2ed94a9
+              rb110bcc
 #include "Attribute.h"                // for Attribute
+#include "Common/ToString.hpp"        // for toCString
 #include "Common/utility.h"           // for cloneAll, deleteAll, printAll
 #include "InitTweak/InitTweak.h"      // for getPointerBase
 …
 int Type::referenceDepth() const { return 0; }
+AggregateDecl * Type::getAggr() const {
+        assertf( false, "Non-aggregate type: %s", toCString( this ) );
+}
 TypeSubstitution Type::genericSubstitution() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }

src/SynTree/Type.h

-              r2ed94a9
+              rb110bcc
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 14 15:40:00 2021
 // Update Count     : 171
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Feb 19 22:37:10 2023
+// Update Count     : 176
 //
 …
 #include "BaseSyntaxNode.h"  // for BaseSyntaxNode
 #include "Common/utility.h"  // for operator+
+#include "Common/Iterate.hpp"// for operator+
 #include "Mutator.h"         // for Mutator
 #include "SynTree.h"         // for AST nodes
 …
                 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
                 bool operator<=( Qualifiers other ) const {
                         return is_const    <= other.is_const        //Any non-const converts to const without cost
                                         && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
                                         && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
                                         && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
+                        return is_const    <= other.is_const        // Any non-const converts to const without cost
+                                && is_volatile <= other.is_volatile             // Any non-volatile converts to volatile without cost
+                                && is_mutex    >= other.is_mutex                // Any mutex converts to non-mutex without cost
+                                && is_atomic   == other.is_atomic;              // No conversion from atomic to non atomic is free
+                }
                 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
 …
         virtual bool isComplete() const { return true; }
         virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
+        virtual AggregateDecl * getAggr() const;
         virtual TypeSubstitution genericSubstitution() const;
         virtual Type *clone() const = 0;
+        virtual Type * clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
         virtual void accept( Visitor & v ) const = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
+        virtual Type * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual bool isComplete() const override { return false; }
         virtual VoidType *clone() const override { return new VoidType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual VoidType * clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         // GENERATED END
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
+        static const char * typeNames[];                                        // string names for basic types, MUST MATCH with Kind
         BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 …
         void set_kind( Kind newValue ) { kind = newValue; }
         virtual BasicType *clone() const override { return new BasicType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual BasicType * clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         bool isInteger() const;
 …
         // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
+        Expression * dimension;
         bool isVarLen;
         bool isStatic;
         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const PointerType& );
         virtual ~PointerType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         Expression *get_dimension() { return dimension; }
         void set_dimension( Expression *newValue ) { dimension = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        Expression * get_dimension() { return dimension; }
+        void set_dimension( Expression * newValue ) { dimension = newValue; }
         bool get_isVarLen() { return isVarLen; }
         void set_isVarLen( bool newValue ) { isVarLen = newValue; }
 …
         virtual bool isComplete() const override { return ! isVarLen; }
         virtual PointerType *clone() const override { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual PointerType * clone() const override { return new PointerType( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ArrayType : public Type {
   public:
         Type *base;
         Expression *dimension;
+        Type * base;
+        Expression * dimension;
         bool isVarLen;
         bool isStatic;
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
         virtual ~ArrayType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         Expression *get_dimension() { return dimension; }
         void set_dimension( Expression *newValue ) { dimension = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        Expression * get_dimension() { return dimension; }
+        void set_dimension( Expression * newValue ) { dimension = newValue; }
         bool get_isVarLen() { return isVarLen; }
         void set_isVarLen( bool newValue ) { isVarLen = newValue; }
 …
         virtual bool isComplete() const override { return dimension || isVarLen; }
         virtual ArrayType *clone() const override { return new ArrayType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ArrayType * clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual ~QualifiedType();
         virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual QualifiedType * clone() const override { return new QualifiedType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ReferenceType : public Type {
 public:
         Type *base;
         ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        Type * base;
+        ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ReferenceType( const ReferenceType & );
         virtual ~ReferenceType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
         virtual int referenceDepth() const override;
 …
         virtual TypeSubstitution genericSubstitution() const override;
         virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ReferenceType * clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual FunctionType * clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ReferenceToType : public Type {
   public:
         std::list< Expression* > parameters;
+        std::list< Expression * > parameters;
         std::string name;
         bool hoistType;
 …
         void set_hoistType( bool newValue ) { hoistType = newValue; }
         virtual ReferenceToType *clone() const override = 0;
+        virtual ReferenceToType * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
         virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual Type * acceptMutator( Mutator & m ) override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
         // where the structure used in this type is actually defined
         StructDecl *baseStruct;
+        StructDecl * baseStruct;
         StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
 …
         StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
         StructDecl *get_baseStruct() const { return baseStruct; }
         void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+        StructDecl * get_baseStruct() const { return baseStruct; }
+        void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; }
         /// Accesses generic parameters of base struct (NULL if none such)
 …
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
         virtual StructInstType *clone() const override { return new StructInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual StructInstType * clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
         UnionDecl *baseUnion;
+        UnionDecl * baseUnion;
         UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
 …
         UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
         UnionDecl *get_baseUnion() const { return baseUnion; }
+        UnionDecl * get_baseUnion() const { return baseUnion; }
         void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
 …
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
         virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual UnionInstType * clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
         // where the enum used in this type is actually defined
         EnumDecl *baseEnum = nullptr;
+        EnumDecl * baseEnum = nullptr;
         EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
 …
         EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
         EnumDecl *get_baseEnum() const { return baseEnum; }
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
+        EnumDecl * get_baseEnum() const { return baseEnum; }
+        void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; }
         virtual bool isComplete() const override;
 …
         virtual AggregateDecl * getAggr() const override;
         virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual EnumInstType * clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         virtual bool isComplete() const override;
         virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TraitInstType * clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
         virtual std::string typeString() const override;
 …
         // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
         // where the type used here is actually defined
         TypeDecl *baseType;
+        TypeDecl * baseType;
         bool isFtype;
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const TypeInstType & other );
         ~TypeInstType();
         TypeDecl *get_baseType() const { return baseType; }
         void set_baseType( TypeDecl *newValue );
+        TypeDecl * get_baseType() const { return baseType; }
+        void set_baseType( TypeDecl * newValue );
         bool get_isFtype() const { return isFtype; }
         void set_isFtype( bool newValue ) { isFtype = newValue; }
 …
         virtual bool isComplete() const override;
         virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TypeInstType * clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
 …
         // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
         virtual TupleType *clone() const override { return new TupleType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TupleType * clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class TypeofType : public Type {
   public:
         Expression *expr;    ///< expression to take the type of
         bool is_basetypeof;  ///< true iff is basetypeof type
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+        Expression * expr;              ///< expression to take the type of
+        bool is_basetypeof;             ///< true iff is basetypeof type
+        TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof,
                 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
+        Expression * get_expr() const { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
         virtual bool isComplete() const override { assert( false ); return false; }
         virtual TypeofType *clone() const override { return new TypeofType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TypeofType * clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class VTableType : public Type {
 public:
         Type *base;
         VTableType( const Type::Qualifiers & tq, Type *base,
+        Type * base;
+        VTableType( const Type::Qualifiers & tq, Type * base,
                 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         VTableType( const VTableType & );
         virtual ~VTableType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         virtual VTableType *clone() const override { return new VTableType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        virtual VTableType * clone() const override { return new VTableType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
   public:
         std::string name;
         Expression *expr;
         Type *type;
+        Expression * expr;
+        Type * type;
         bool isType;
         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         AttrType( const AttrType& );
         virtual ~AttrType();
 …
         const std::string & get_name() const { return name; }
         void set_name( const std::string & newValue ) { name = newValue; }
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
         Type *get_type() const { return type; }
         void set_type( Type *newValue ) { type = newValue; }
+        Expression * get_expr() const { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+        Type * get_type() const { return type; }
+        void set_type( Type * newValue ) { type = newValue; }
         bool get_isType() const { return isType; }
         void set_isType( bool newValue ) { isType = newValue; }
 …
         virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
         virtual AttrType *clone() const override { return new AttrType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual AttrType * clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual bool isComplete() const override{ return true; } // xxx - is this right?
         virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual VarArgsType * clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual ZeroType *clone() const override { return new ZeroType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ZeroType * clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual OneType *clone() const override { return new OneType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual OneType * clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         GlobalScopeType();
         virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };

src/Validate/Autogen.cpp

-              r2ed94a9
+              rb110bcc
 #include "InitTweak/GenInit.h"     // for fixReturnStatements
 #include "InitTweak/InitTweak.h"   // for isAssignment, isCopyConstructor
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"        // for Mangler
 #include "CompilationState.h"
 …
         for ( unsigned int index = 0 ; index < fields ; ++index ) {
                 auto member = aggr->members[index].strict_as<ast::DeclWithType>();
                 if ( SymTab::isUnnamedBitfield(
+                if ( ast::isUnnamedBitfield(
                                 dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
                         if ( index == fields - 1 ) {
 …
                 // Not sure why it could be null.
                 // Don't make a function for a parameter that is an unnamed bitfield.
                 if ( nullptr == field || SymTab::isUnnamedBitfield( field ) ) {
+                if ( nullptr == field || ast::isUnnamedBitfield( field ) ) {
                         continue;
                 // Matching Parameter: Initialize the field by copy.

src/Validate/FixQualifiedTypes.cpp

-              r2ed94a9
+              rb110bcc
 #include "Validate/FixQualifiedTypes.hpp"
+#include "AST/LinkageSpec.hpp"             // for Linkage
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
+#include "Common/ToString.hpp"             // for toString
+#include "SymTab/Mangler.h"                // for Mangler
 #include "Validate/NoIdSymbolTable.hpp"
-#include "SymTab/Mangler.h"            // for Mangler
-#include "AST/LinkageSpec.hpp"                     // for Linkage
 namespace Validate {

src/Validate/ForallPointerDecay.cpp

r2ed94a9	rb110bcc
22	22	#include "CodeGen/OperatorTable.h"
23	23	#include "Common/CodeLocation.h"
	24	#include "Common/ToString.hpp"
24	25	#include "SymTab/FixFunction.h"
25	26

src/Validate/HandleAttributes.cc

-              r2ed94a9
+              rb110bcc
 #include "CompilationState.h"
+#include "Common/Eval.h"
 #include "Common/PassVisitor.h"
+#include "Common/ToString.hpp"
 #include "Common/SemanticError.h"
 #include "ResolvExpr/Resolver.h"

src/Validate/HoistStruct.cpp

-              r2ed94a9
+              rb110bcc
 #include "Validate/HoistStruct.hpp"
+#include <sstream>
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
-#include "Common/utility.h"
 namespace Validate {

src/Virtual/module.mk

r2ed94a9	rb110bcc
19	19	Virtual/ExpandCasts.h \
20	20	Virtual/Tables.cc \
21		Virtual/Tables.h
	21	Virtual/Tables.h \
	22	Virtual/VirtualDtor.cpp \
	23	Virtual/VirtualDtor.hpp

src/include/cassert

-              r2ed94a9
+              rb110bcc
 #include_next <cassert>
+#include <string>
+template < typename ... Params >
+std::string toString( const Params & ... params );
+#include "Common/ToString.hpp"
 #ifdef NDEBUG

src/main.cc

-              r2ed94a9
+              rb110bcc
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Oct  5 12:06:00 2022
 // Update Count     : 679
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 21:12:17 2023
+// Update Count     : 682
 //
 …
 #include "AST/Convert.hpp"
+#include "AST/Util.hpp"                     // for checkInvariants
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
 …
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
-#include "Common/CompilerError.h"           // for CompilerError
 #include "Common/DeclStats.hpp"             // for printDeclStats
 #include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"                   // for Stats
-#include "Common/UnimplementedError.h"      // for UnimplementedError
 #include "Common/utility.h"                 // for deleteAll, filter, printAll
 #include "Concurrency/Actors.hpp"           // for implementActors
 …
 #include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
 #include "Virtual/ExpandCasts.h"            // for expandCasts
+#include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
 static void NewPass( const char * const name ) {
 …
+}
+#define PASS( name, pass )                  \
+// Helpers for checkInvariant:
+void checkInvariants( std::list< Declaration * > & ) {}
+using ast::checkInvariants;
+#define PASS( name, pass, unit, ... )       \
         if ( errorp ) { cerr << name << endl; } \
         NewPass(name);                          \
         Stats::Time::StartBlock(name);          \
+        pass;                                   \
+        Stats::Time::StopBlock();
+        pass(unit,##__VA_ARGS__);               \
+        Stats::Time::StopBlock();               \
+        if ( invariant ) {                      \
+                checkInvariants(unit);              \
+        }
+#define DUMP( cond, unit )                  \
+        if ( cond ) {                           \
+                dump(unit);                         \
+                return EXIT_SUCCESS;                \
+        }
 static bool waiting_for_gdb = false;                                    // flag to set cfa-cpp to wait for gdb on start
 …
                         FILE * gcc_builtins = fopen( (PreludeDirector + "/gcc-builtins.cf").c_str(), "r" );
                         assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" );
                         parse( gcc_builtins, LinkageSpec::Compiler );
+                        parse( gcc_builtins, ast::Linkage::Compiler );
                         // read the extra prelude in, if not generating the cfa library
                         FILE * extras = fopen( (PreludeDirector + "/extras.cf").c_str(), "r" );
                         assertf( extras, "cannot open extras.cf\n" );
                         parse( extras, LinkageSpec::BuiltinC );
+                        parse( extras, ast::Linkage::BuiltinC );
                         if ( ! libcfap ) {
 …
                                 FILE * prelude = fopen( (PreludeDirector + "/prelude.cfa").c_str(), "r" );
                                 assertf( prelude, "cannot open prelude.cfa\n" );
                                 parse( prelude, LinkageSpec::Intrinsic );
+                                parse( prelude, ast::Linkage::Intrinsic );
                                 // Read to cfa builtins, if not generating the cfa library
                                 FILE * builtins = fopen( (PreludeDirector + "/builtins.cf").c_str(), "r" );
                                 assertf( builtins, "cannot open builtins.cf\n" );
                                 parse( builtins, LinkageSpec::BuiltinCFA );
                         } // if
                 } // if
                 parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, yydebug );
+                                parse( builtins, ast::Linkage::BuiltinCFA );
+                        } // if
+                } // if
+                parse( input, libcfap ? ast::Linkage::Intrinsic : ast::Linkage::Cforall, yydebug );
                 transUnit = buildUnit();
+                if ( astp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( astp, std::move( transUnit ) );
                 Stats::Time::StopBlock();
 …
+                }
+                PASS( "Hoist Type Decls", Validate::hoistTypeDecls( transUnit ) );
+                // Hoist Type Decls pulls some declarations out of contexts where
+                // locations are not tracked. Perhaps they should be, but for now
+                // the full fill solves it.
+                forceFillCodeLocations( transUnit );
+                PASS( "Translate Exception Declarations", ControlStruct::translateExcept( transUnit ) );
+                if ( exdeclp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                }
+                PASS( "Verify Ctor, Dtor & Assign", Validate::verifyCtorDtorAssign( transUnit ) );
+                PASS( "Replace Typedefs", Validate::replaceTypedef( transUnit ) );
+                PASS( "Fix Return Types", Validate::fixReturnTypes( transUnit ) );
+                PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers( transUnit ) );
+                PASS( "Link Reference To Types", Validate::linkReferenceToTypes( transUnit ) );
+                PASS( "Fix Qualified Types", Validate::fixQualifiedTypes( transUnit ) );
+                PASS( "Hoist Struct", Validate::hoistStruct( transUnit ) );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef( transUnit ) );
+                PASS( "Validate Generic Parameters", Validate::fillGenericParameters( transUnit ) );
+                PASS( "Translate Dimensions", Validate::translateDimensionParameters( transUnit ) );
+                PASS( "Check Function Returns", Validate::checkReturnStatements( transUnit ) );
+                PASS( "Fix Return Statements", InitTweak::fixReturnStatements( transUnit ) );
+                PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords( transUnit ) );
+                PASS( "Forall Pointer Decay", Validate::decayForallPointers( transUnit ) );
+                PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
+                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
+        PASS( "Implement Actors", Concurrency::implementActors( transUnit ) );
+                PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
+                PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
+                PASS( "Compound Literal", Validate::handleCompoundLiterals( transUnit ) );
+                PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
+                PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
+                PASS( "Fix Label Address", Validate::fixLabelAddresses( transUnit ) );
+                PASS( "Hoist Type Decls", Validate::hoistTypeDecls, transUnit );
+                PASS( "Translate Exception Declarations", ControlStruct::translateExcept, transUnit );
+                DUMP( exdeclp, std::move( transUnit ) );
+                PASS( "Verify Ctor, Dtor & Assign", Validate::verifyCtorDtorAssign, transUnit );
+                PASS( "Replace Typedefs", Validate::replaceTypedef, transUnit );
+                PASS( "Fix Return Types", Validate::fixReturnTypes, transUnit );
+                PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers, transUnit );
+                PASS( "Link Reference To Types", Validate::linkReferenceToTypes, transUnit );
+                PASS( "Fix Qualified Types", Validate::fixQualifiedTypes, transUnit );
+                PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
+                PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
+                PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );
+                PASS( "Check Function Returns", Validate::checkReturnStatements, transUnit );
+                PASS( "Fix Return Statements", InitTweak::fixReturnStatements, transUnit );
+                PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords, transUnit );
+                PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );
+                PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls, transUnit );
+                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit );
+                PASS( "Implement Actors", Concurrency::implementActors, transUnit );
+                PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );
+                PASS( "Implement Mutex", Concurrency::implementMutex, transUnit );
+                PASS( "Implement Thread Start", Concurrency::implementThreadStarter, transUnit );
+                PASS( "Compound Literal", Validate::handleCompoundLiterals, transUnit );
+                PASS( "Set Length From Initializer", Validate::setLengthFromInitializer, transUnit );
+                PASS( "Find Global Decls", Validate::findGlobalDecls, transUnit );
+                PASS( "Fix Label Address", Validate::fixLabelAddresses, transUnit );
                 if ( symtabp ) {
 …
                 } // if
+                if ( validp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Translate Throws", ControlStruct::translateThrows( transUnit ) );
+                PASS( "Fix Labels", ControlStruct::fixLabels( transUnit ) );
+                PASS( "Fix Names", CodeGen::fixNames( transUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( transUnit ) );
+                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
+                DUMP( validp, std::move( transUnit ) );
+                PASS( "Translate Throws", ControlStruct::translateThrows, transUnit );
+                PASS( "Fix Labels", ControlStruct::fixLabels, transUnit );
+                PASS( "Fix Names", CodeGen::fixNames, transUnit );
+                PASS( "Gen Init", InitTweak::genInit, transUnit );
+                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples, transUnit );
                 if ( libcfap ) {
 …
                 } // if
+                if ( bresolvep ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( bresolvep, std::move( transUnit ) );
                 if ( resolvprotop ) {
 …
                 } // if
+                PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                if ( exprp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                forceFillCodeLocations( transUnit );
+                PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
+                PASS( "Resolve", ResolvExpr::resolve, transUnit );
+                DUMP( exprp, std::move( transUnit ) );
+                PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() );
                 // fix ObjectDecl - replaces ConstructorInit nodes
+                if ( ctorinitp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( ctorinitp, std::move( transUnit ) );
                 // Currently not working due to unresolved issues with UniqueExpr
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 PASS( "Translate Tries", ControlStruct::translateTries( transUnit ) );
                 PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
+                PASS( "Expand Unique Expr", Tuples::expandUniqueExpr, transUnit ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+                PASS( "Translate Tries", ControlStruct::translateTries, transUnit );
+                PASS( "Gen Waitfor", Concurrency::generateWaitFor, transUnit );
                 // Needs to happen before tuple types are expanded.
+                PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) );
+                PASS( "Expand Tuples", Tuples::expandTuples( transUnit ) );
+                if ( tuplep ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Convert Specializations",  GenPoly::convertSpecializations, transUnit );
+                PASS( "Expand Tuples", Tuples::expandTuples, transUnit );
+                DUMP( tuplep, std::move( transUnit ) );
                 // Must come after Translate Tries.
+                PASS( "Virtual Expand Casts", Virtual::expandCasts( transUnit ) );
+                PASS( "Instantiate Generics", GenPoly::instantiateGeneric( transUnit ) );
+                if ( genericsp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Convert L-Value", GenPoly::convertLvalue( transUnit ) );
+                PASS( "Virtual Expand Casts", Virtual::expandCasts, transUnit );
+                PASS( "Instantiate Generics", GenPoly::instantiateGeneric, transUnit );
+                DUMP( genericsp, std::move( transUnit ) );
+                PASS( "Convert L-Value", GenPoly::convertLvalue, transUnit );
                 translationUnit = convert( std::move( transUnit ) );
+                if ( bboxp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Box", GenPoly::box( translationUnit ) );
+                PASS( "Link-Once", CodeGen::translateLinkOnce( translationUnit ) );
+                DUMP( bboxp, translationUnit );
+                PASS( "Box", GenPoly::box, translationUnit );
+                PASS( "Link-Once", CodeGen::translateLinkOnce, translationUnit );
                 // Code has been lowered to C, now we can start generation.
+                if ( bcodegenp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( bcodegenp, translationUnit );
                 if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
 …
                 CodeTools::fillLocations( translationUnit );
                 PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
+                PASS( "Code Gen", CodeGen::generate, translationUnit, *output, ! genproto, prettycodegenp, true, linemarks );
                 CodeGen::FixMain::fix( translationUnit, *output,
 …
                 } // if
                 e.print();
-                if ( output != &cout ) {
-                        delete output;
-                } // if
-                return EXIT_FAILURE;
-        } catch ( UnimplementedError & e ) {
-                cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
-                if ( output != &cout ) {
-                        delete output;
-                } // if
-                return EXIT_FAILURE;
-        } catch ( CompilerError & e ) {
-                cerr << "Compiler Error: " << e.get_what() << endl;
-                cerr << "(please report bugs to [REDACTED])" << endl;
                 if ( output != &cout ) {
                         delete output;
 …
 static const char optstring[] = ":c:ghlLmNnpdP:S:twW:D:";
+static const char optstring[] = ":c:ghilLmNnpdP:S:twW:D:";
 enum { PreludeDir = 128 };
 …
         { "gdb", no_argument, nullptr, 'g' },
         { "help", no_argument, nullptr, 'h' },
+        { "invariant", no_argument, nullptr, 'i' },
         { "libcfa", no_argument, nullptr, 'l' },
         { "linemarks", no_argument, nullptr, 'L' },
         { "no-main", no_argument, 0, 'm' },
+        { "no-main", no_argument, nullptr, 'm' },
         { "no-linemarks", no_argument, nullptr, 'N' },
         { "no-prelude", no_argument, nullptr, 'n' },
 …
         "wait for gdb to attach",                                                       // -g
         "print translator help message",                                        // -h
+        "invariant checking during AST passes",                         // -i
         "generate libcfa.c",                                                            // -l
         "generate line marks",                                                          // -L
 …
                         usage( argv );                                                          // no return
                         break;
+                  case 'i':                                                                             // invariant checking
+                        invariant = true;
+                        break;
                   case 'l':                                                                             // generate libcfa.c
                         libcfap = true;

tests/.expect/PRNG.x64.txt

-              r2ed94a9
+              rb110bcc
+CFA xoshiro256pp
                     PRNG()     PRNG(5)   PRNG(0,5)
                 8464106481           4           4
        5215204710507639537           1           2
        1880401021892145483           0           4
       12503840966285181348           2           5
         801971300205459356           0           2
        6123812066052045228           3           1
        7691074772031490538           4           3
        4793575011534070065           0           0
       10647551928893428440           1           3
       10865128702974868079           0           3
         530720947131684825           3           0
       10520125295812061287           1           5
        7539957561855178679           4           4
       13739826796006269835           0           2
        4289714351582916365           3           2
       16911914987551424434           2           1
        5327155553462670435           4           0
       16251986870929071204           4           4
       13394433706240223001           0           3
        4814982023332666924           4           0
+      13944458589275087071           3           2
+        129977468648444256           0           4
+       2357727400298891021           2           2
+       8855179187835660146           3           3
+       9957620185645882382           4           1
+      13396406983727409795           0           5
+       3342782395220265920           0           5
+       1707651271867677937           1           0
+      16402561450140881681           0           1
+      17838519215740313729           4           2
+       7425936020594490136           4           0
+       4174865704721714670           3           5
+      16055269689200152092           0           2
+      15091270195803594018           1           5
+      11807315541476180798           1           1
+      10697186588988060306           4           1
+      14665526411527044929           3           2
+      11289342279096164771           2           5
+      16126980828050300615           1           4
+       7821578301767524260           4           1
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
                     prng()     prng(5)   prng(0,5)
                 8464106481           4           4
        5215204710507639537           1           2
        1880401021892145483           0           4
       12503840966285181348           2           5
         801971300205459356           0           2
        6123812066052045228           3           1
        7691074772031490538           4           3
        4793575011534070065           0           0
       10647551928893428440           1           3
       10865128702974868079           0           3
         530720947131684825           3           0
       10520125295812061287           1           5
        7539957561855178679           4           4
       13739826796006269835           0           2
        4289714351582916365           3           2
       16911914987551424434           2           1
        5327155553462670435           4           0
       16251986870929071204           4           4
       13394433706240223001           0           3
        4814982023332666924           4           0
+      13944458589275087071           3           2
+        129977468648444256           0           4
+       2357727400298891021           2           2
+       8855179187835660146           3           3
+       9957620185645882382           4           1
+      13396406983727409795           0           5
+       3342782395220265920           0           5
+       1707651271867677937           1           0
+      16402561450140881681           0           1
+      17838519215740313729           4           2
+       7425936020594490136           4           0
+       4174865704721714670           3           5
+      16055269689200152092           0           2
+      15091270195803594018           1           5
+      11807315541476180798           1           1
+      10697186588988060306           4           1
+      14665526411527044929           3           2
+      11289342279096164771           2           5
+      16126980828050300615           1           4
+       7821578301767524260           4           1
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
 Concurrent
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
                    prng(t)   prng(t,5) prng(t,0,5)
                 8464106481           4           4
        5215204710507639537           1           2
        1880401021892145483           0           4
       12503840966285181348           2           5
         801971300205459356           0           2
        6123812066052045228           3           1
        7691074772031490538           4           3
        4793575011534070065           0           0
       10647551928893428440           1           3
       10865128702974868079           0           3
         530720947131684825           3           0
       10520125295812061287           1           5
        7539957561855178679           4           4
       13739826796006269835           0           2
        4289714351582916365           3           2
       16911914987551424434           2           1
        5327155553462670435           4           0
       16251986870929071204           4           4
       13394433706240223001           0           3
        4814982023332666924           4           0
+      13944458589275087071           3           2
+        129977468648444256           0           4
+       2357727400298891021           2           2
+       8855179187835660146           3           3
+       9957620185645882382           4           1
+      13396406983727409795           0           5
+       3342782395220265920           0           5
+       1707651271867677937           1           0
+      16402561450140881681           0           1
+      17838519215740313729           4           2
+       7425936020594490136           4           0
+       4174865704721714670           3           5
+      16055269689200152092           0           2
+      15091270195803594018           1           5
+      11807315541476180798           1           1
+      10697186588988060306           4           1
+      14665526411527044929           3           2
+      11289342279096164771           2           5
+      16126980828050300615           1           4
+       7821578301767524260           4           1
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
 trials 100000000 buckets 100000 min 871 max 1144 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%

tests/.expect/PRNG.x86.txt

-              r2ed94a9
+              rb110bcc
+CFA xoshiro128pp
                     PRNG()     PRNG(5)   PRNG(0,5)
            1           1
                 4074541490           0           0
                  927506267           0           3
                 1991273445           1           3
                  669918146           2           3
                  519546860           1           1
                 1136699882           4           3
                 2130185384           3           1
                  992239050           0           5
                 2250903111           0           1
                 1544429724           3           2
                 1591091660           3           3
                 2511657707           2           4
                 1065770984           2           4
                 2412763405           4           4
                 1834447239           4           2
                  360289337           0           4
                 2449452027           1           1
                 3370425396           2           1
                 3109103043           0           3
+                2884683541           0           0
+                3465286746           2           4
+                3268922916           0           1
+                2396374907           3           0
+                2135076892           4           1
+                 944377718           3           1
+                2204845346           3           3
+                3736609533           0           4
+                4063231336           0           2
+                1075394776           0           2
+                 712844808           4           0
+                4246343110           3           1
+                3793873837           2           1
+                3690340337           1           4
+                 319207944           1           4
+                1815791072           3           5
+                2581617261           1           5
+                3873329448           1           3
+                 832631329           4           0
+                 651551615           3           5
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
                     prng()     prng(5)   prng(0,5)
            1           1
                 4074541490           0           0
                  927506267           0           3
                 1991273445           1           3
                  669918146           2           3
                  519546860           1           1
                 1136699882           4           3
                 2130185384           3           1
                  992239050           0           5
                 2250903111           0           1
                 1544429724           3           2
                 1591091660           3           3
                 2511657707           2           4
                 1065770984           2           4
                 2412763405           4           4
                 1834447239           4           2
                  360289337           0           4
                 2449452027           1           1
                 3370425396           2           1
                 3109103043           0           3
+                2884683541           0           0
+                3465286746           2           4
+                3268922916           0           1
+                2396374907           3           0
+                2135076892           4           1
+                 944377718           3           1
+                2204845346           3           3
+                3736609533           0           4
+                4063231336           0           2
+                1075394776           0           2
+                 712844808           4           0
+                4246343110           3           1
+                3793873837           2           1
+                3690340337           1           4
+                 319207944           1           4
+                1815791072           3           5
+                2581617261           1           5
+                3873329448           1           3
+                 832631329           4           0
+                 651551615           3           5
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
 Concurrent
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
                    prng(t)   prng(t,5) prng(t,0,5)
            1           1
                 4074541490           0           0
                  927506267           0           3
                 1991273445           1           3
                  669918146           2           3
                  519546860           1           1
                 1136699882           4           3
                 2130185384           3           1
                  992239050           0           5
                 2250903111           0           1
                 1544429724           3           2
                 1591091660           3           3
                 2511657707           2           4
                 1065770984           2           4
                 2412763405           4           4
                 1834447239           4           2
                  360289337           0           4
                 2449452027           1           1
                 3370425396           2           1
                 3109103043           0           3
+                2884683541           0           0
+                3465286746           2           4
+                3268922916           0           1
+                2396374907           3           0
+                2135076892           4           1
+                 944377718           3           1
+                2204845346           3           3
+                3736609533           0           4
+                4063231336           0           2
+                1075394776           0           2
+                 712844808           4           0
+                4246343110           3           1
+                3793873837           2           1
+                3690340337           1           4
+                 319207944           1           4
+                1815791072           3           5
+                2581617261           1           5
+                3873329448           1           3
+                 832631329           4           0
+                 651551615           3           5
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
 trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%

tests/.expect/attributes.arm64.txt

-              r2ed94a9
+              rb110bcc
     return _X4_retS12__anonymous0_1;
+}
 __attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
+__attribute__ ((unused)) static struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(__attribute__ ((unused)) signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.x64.txt

-              r2ed94a9
+              rb110bcc
     return _X4_retS12__anonymous0_1;
+}
 __attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
+__attribute__ ((unused)) static struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(__attribute__ ((unused)) signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.x86.txt

-              r2ed94a9
+              rb110bcc
     return _X4_retS12__anonymous0_1;
+}
 __attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
+__attribute__ ((unused)) static struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(__attribute__ ((unused)) signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/declarationSpecifier.arm64.txt

-              r2ed94a9
+              rb110bcc
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
+static volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
+static volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
+static volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
     signed int _X1ii_1;
 …
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
-struct __anonymous7 {
-    signed int _X1ii_1;
-};
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+}
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+    {
-        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
-    return _X4_retS12__anonymous7_1;
+}
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
-static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
 static volatile const signed short int _X3x21KVs_1;
 …
 static volatile const signed short int _X3x26KVs_1;
 static volatile const signed short int _X3x27KVs_1;
+struct __anonymous7 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+    return _X4_retS12__anonymous7_1;
+}
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous7 _X3x29KVS12__anonymous7_1;
 struct __anonymous8 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
+static volatile const struct __anonymous8 _X3x30KVS12__anonymous8_1;
 struct __anonymous9 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
+static volatile const struct __anonymous9 _X3x31KVS12__anonymous9_1;
 struct __anonymous10 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
+static volatile const struct __anonymous10 _X3x32KVS13__anonymous10_1;
 struct __anonymous11 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
+static volatile const struct __anonymous11 _X3x33KVS13__anonymous11_1;
 struct __anonymous12 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
+static volatile const struct __anonymous12 _X3x34KVS13__anonymous12_1;
 struct __anonymous13 {
     signed short int _X1is_1;
 …
+}
+static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
+struct __anonymous14 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
+struct __anonymous15 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
+static volatile const struct __anonymous13 _X3x35KVS13__anonymous13_1;
 _Thread_local signed int _X3x37i_1;
 __thread signed int _X3x38i_1;
 …
 static inline volatile const signed short int _X3f27Fs___1();
 static inline volatile const signed short int _X3f28Fs___1();
+struct __anonymous14 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous14 _X3f31FS13__anonymous14___1();
+struct __anonymous15 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous15 _X3f32FS13__anonymous15___1();
 struct __anonymous16 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
+static inline volatile const struct __anonymous16 _X3f33FS13__anonymous16___1();
 struct __anonymous17 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
+static inline volatile const struct __anonymous17 _X3f34FS13__anonymous17___1();
 struct __anonymous18 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
+static inline volatile const struct __anonymous18 _X3f35FS13__anonymous18___1();
 struct __anonymous19 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
+static inline volatile const struct __anonymous19 _X3f36FS13__anonymous19___1();
 struct __anonymous20 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
+static inline volatile const struct __anonymous20 _X3f37FS13__anonymous20___1();
 struct __anonymous21 {
     signed int _X1ii_1;
 …
+}
+static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
+struct __anonymous22 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+    return _X4_retS13__anonymous22_1;
+}
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
+struct __anonymous23 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+    return _X4_retS13__anonymous23_1;
+}
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
+static inline volatile const struct __anonymous21 _X3f38FS13__anonymous21___1();
 static inline volatile const signed short int _X3f41Fs___1();
 static inline volatile const signed short int _X3f42Fs___1();

tests/.expect/declarationSpecifier.x64.txt

-              r2ed94a9
+              rb110bcc
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
+static volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
+static volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
+static volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
     signed int _X1ii_1;
 …
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
-struct __anonymous7 {
-    signed int _X1ii_1;
-};
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+}
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+    {
-        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
-    return _X4_retS12__anonymous7_1;
+}
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
-static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
 static volatile const signed short int _X3x21KVs_1;
 …
 static volatile const signed short int _X3x26KVs_1;
 static volatile const signed short int _X3x27KVs_1;
+struct __anonymous7 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+    return _X4_retS12__anonymous7_1;
+}
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous7 _X3x29KVS12__anonymous7_1;
 struct __anonymous8 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
+static volatile const struct __anonymous8 _X3x30KVS12__anonymous8_1;
 struct __anonymous9 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
+static volatile const struct __anonymous9 _X3x31KVS12__anonymous9_1;
 struct __anonymous10 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
+static volatile const struct __anonymous10 _X3x32KVS13__anonymous10_1;
 struct __anonymous11 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
+static volatile const struct __anonymous11 _X3x33KVS13__anonymous11_1;
 struct __anonymous12 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
+static volatile const struct __anonymous12 _X3x34KVS13__anonymous12_1;
 struct __anonymous13 {
     signed short int _X1is_1;
 …
+}
+static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
+struct __anonymous14 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
+struct __anonymous15 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
+static volatile const struct __anonymous13 _X3x35KVS13__anonymous13_1;
 _Thread_local signed int _X3x37i_1;
 __thread signed int _X3x38i_1;
 …
 static inline volatile const signed short int _X3f27Fs___1();
 static inline volatile const signed short int _X3f28Fs___1();
+struct __anonymous14 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous14 _X3f31FS13__anonymous14___1();
+struct __anonymous15 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous15 _X3f32FS13__anonymous15___1();
 struct __anonymous16 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
+static inline volatile const struct __anonymous16 _X3f33FS13__anonymous16___1();
 struct __anonymous17 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
+static inline volatile const struct __anonymous17 _X3f34FS13__anonymous17___1();
 struct __anonymous18 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
+static inline volatile const struct __anonymous18 _X3f35FS13__anonymous18___1();
 struct __anonymous19 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
+static inline volatile const struct __anonymous19 _X3f36FS13__anonymous19___1();
 struct __anonymous20 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
+static inline volatile const struct __anonymous20 _X3f37FS13__anonymous20___1();
 struct __anonymous21 {
     signed int _X1ii_1;
 …
+}
+static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
+struct __anonymous22 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+    return _X4_retS13__anonymous22_1;
+}
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
+struct __anonymous23 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+    return _X4_retS13__anonymous23_1;
+}
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
+static inline volatile const struct __anonymous21 _X3f38FS13__anonymous21___1();
 static inline volatile const signed short int _X3f41Fs___1();
 static inline volatile const signed short int _X3f42Fs___1();

tests/.expect/declarationSpecifier.x86.txt

-              r2ed94a9
+              rb110bcc
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
+static volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
+static volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
+static volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
     signed int _X1ii_1;
 …
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
-struct __anonymous7 {
-    signed int _X1ii_1;
-};
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+}
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+    {
-        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
-    return _X4_retS12__anonymous7_1;
+}
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
-static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
 static volatile const signed short int _X3x21KVs_1;
 …
 static volatile const signed short int _X3x26KVs_1;
 static volatile const signed short int _X3x27KVs_1;
+struct __anonymous7 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+    return _X4_retS12__anonymous7_1;
+}
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous7 _X3x29KVS12__anonymous7_1;
 struct __anonymous8 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
+static volatile const struct __anonymous8 _X3x30KVS12__anonymous8_1;
 struct __anonymous9 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
+static volatile const struct __anonymous9 _X3x31KVS12__anonymous9_1;
 struct __anonymous10 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
+static volatile const struct __anonymous10 _X3x32KVS13__anonymous10_1;
 struct __anonymous11 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
+static volatile const struct __anonymous11 _X3x33KVS13__anonymous11_1;
 struct __anonymous12 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
+static volatile const struct __anonymous12 _X3x34KVS13__anonymous12_1;
 struct __anonymous13 {
     signed short int _X1is_1;
 …
+}
+static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
+struct __anonymous14 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
+struct __anonymous15 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
+static volatile const struct __anonymous13 _X3x35KVS13__anonymous13_1;
 _Thread_local signed int _X3x37i_1;
 __thread signed int _X3x38i_1;
 …
 static inline volatile const signed short int _X3f27Fs___1();
 static inline volatile const signed short int _X3f28Fs___1();
+struct __anonymous14 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous14 _X3f31FS13__anonymous14___1();
+struct __anonymous15 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous15 _X3f32FS13__anonymous15___1();
 struct __anonymous16 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
+static inline volatile const struct __anonymous16 _X3f33FS13__anonymous16___1();
 struct __anonymous17 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
+static inline volatile const struct __anonymous17 _X3f34FS13__anonymous17___1();
 struct __anonymous18 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
+static inline volatile const struct __anonymous18 _X3f35FS13__anonymous18___1();
 struct __anonymous19 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
+static inline volatile const struct __anonymous19 _X3f36FS13__anonymous19___1();
 struct __anonymous20 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
+static inline volatile const struct __anonymous20 _X3f37FS13__anonymous20___1();
 struct __anonymous21 {
     signed int _X1ii_1;
 …
+}
+static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
+struct __anonymous22 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+    return _X4_retS13__anonymous22_1;
+}
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
+struct __anonymous23 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+    return _X4_retS13__anonymous23_1;
+}
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
+static inline volatile const struct __anonymous21 _X3f38FS13__anonymous21___1();
 static inline volatile const signed short int _X3f41Fs___1();
 static inline volatile const signed short int _X3f42Fs___1();

tests/.expect/nested_function.x64.txt

r2ed94a9	rb110bcc
1		total 155
	1	total 145

tests/.expect/nested_function.x86.txt

r2ed94a9	rb110bcc
1		total 105
	1	total 245

tests/Makefile.am

-              r2ed94a9
+              rb110bcc
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Fri Feb  3 23:06:44 2023
 ## Update Count     : 94
+## Last Modified On : Mon Apr 10 23:24:02 2023
+## Update Count     : 96
 ###############################################################################
 …
 SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator \
         init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment
+        init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment concurrent/waitfor/parse
 $(SYNTAX_ONLY_CODE): % : %.cfa $(CFACCBIN)
         $(CFACOMPILE_SYNTAX)

tests/PRNG.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed Dec 29 09:38:12 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 21 20:39:59 2022
 // Update Count     : 406
+// Last Modified On : Sat Apr 15 16:44:31 2023
+// Update Count     : 419
 //
 …
 #include <stdlib.hfa>                                                                   // PRNG
 #include <clock.hfa>
-#include <thread.hfa>
 #include <limits.hfa>                                                                   // MAX
 #include <math.hfa>                                                                             // sqrt
 #include <malloc.h>                                                                             // malloc_stats
 #include <locale.h>                                                                             // setlocale
+#include <thread.hfa>
 #include <mutex_stmt.hfa>
+#ifdef __x86_64__                                                                               // 64-bit architecture
+#define xstr(s) str(s)
+#define str(s) #s
+#if defined( __x86_64__ ) || defined( __aarch64__ )             // 64-bit architecture
 #define PRNG PRNG64
 #else                                                                                                   // 32-bit architecture
 #define PRNG PRNG32
 #endif // __x86_64__
+//#define TIME
 #ifdef TIME                                                                                             // use -O2 -nodebug
 …
 #endif // TIME
 void avgstd( unsigned int buckets[] ) {
         unsigned int min = MAX, max = 0;
+static void avgstd( size_t trials, size_t buckets[] ) {
+        size_t min = MAX, max = 0;
         double sum = 0.0, diff;
         for ( i; BUCKETS ) {
 …
         } // for
         double std = sqrt( sum / BUCKETS );
         mutex( sout ) sout | "trials"  | TRIALS | "buckets" | BUCKETS
+        mutex( sout ) sout | "trials"  | trials | "buckets" | BUCKETS
                 | "min" | min | "max" | max
                 | "avg" | wd(0,1, avg) | "std" | wd(0,1, std) | "rstd" | wd(0,1, (avg == 0 ? 0.0 : std / avg * 100)) | "%";
 …
 thread T1 {};
 void main( T1 & ) {
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
         for ( TRIALS / 100 ) {
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
+        for ( TRIALS / 50 ) {
                 buckets[rand() % BUCKETS] += 1;                                 // concurrent
         } // for
         avgstd( buckets );
+        avgstd( TRIALS / 50, buckets );
         free( buckets );
 } // main
 …
         PRNG prng;
         if ( seed != 0 ) set_seed( prng, seed );
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
         for ( TRIALS ) {
                 buckets[prng( prng ) % BUCKETS] += 1;                   // concurrent
         } // for
         avgstd( buckets );
+        avgstd( TRIALS, buckets );
         free( buckets );
 } // main
 …
 thread T3 {};
 void main( T3 & th ) {
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
         for ( TRIALS ) {
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
+        for ( TRIALS / 5 ) {
                 buckets[prng() % BUCKETS] += 1;                                 // concurrent
         } // for
         avgstd( buckets );
+        avgstd( TRIALS / 5, buckets );
         free( buckets );
 } // main
 …
 thread T4 {};
 void main( T4 & th ) {
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
         for ( TRIALS ) {
                 buckets[prng( th ) % BUCKETS] += 1;     // concurrent
         } // for
         avgstd( buckets );
+                buckets[prng( th ) % BUCKETS] += 1;                             // concurrent
+        } // for
+        avgstd( TRIALS, buckets );
         free( buckets );
 } // main
 …
 static void dummy( thread$ & th ) __attribute__(( noinline ));
 static void dummy( thread$ & th ) {
         unsigned int * buckets = (unsigned int *)calloc( BUCKETS, sizeof(unsigned int) ); // too big for task stack
         for ( unsigned int i = 0; i < TRIALS; i += 1 ) {
+        size_t * buckets = (size_t *)calloc( BUCKETS, sizeof(size_t) ); // too big for task stack
+        for ( size_t i = 0; i < TRIALS; i += 1 ) {
                 buckets[prng( th ) % BUCKETS] += 1;                             // sequential
         } // for
         avgstd( buckets );
+        avgstd( TRIALS, buckets );
         free( buckets );
 } // dummy
 …
         enum { TASKS = 4 };
         Time start;
 #ifdef TIME                                                                                             // too slow for test and generates non-repeatable results
 #if 1
+        unsigned int rseed;
+        sout | "glib rand" | nl | nl;
+        size_t rseed;
         if ( seed != 0 ) rseed = seed;
         else rseed = rdtscl();
 …
         sout | sepDisable;
         sout | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
+        sout | nl | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
         for ( 20 ) {
                 sout | wd(26, rand()) | nonl;
 …
         STARTTIME;
+        {
                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
                 for ( i; TRIALS / 10 ) {
+                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
+                for ( i; TRIALS / 5 ) {
                         buckets[rand() % BUCKETS] += 1;                         // sequential
                 } // for
                 avgstd( buckets );
+                avgstd( TRIALS / 5, buckets );
                 free( buckets );
+        }
         ENDTIME( " x 10 " );
+        ENDTIME( " x 5 " );
         sout | nl | "Concurrent";
 …
                 } // wait for threads to complete
+        }
         ENDTIME( " x 100 " );
+        ENDTIME( " x 50 " );
 #endif // 0
 #endif // TIME
+        sout | nl | "CFA " xstr(PRNG_NAME);
 #if 1
         PRNG prng;
 …
         STARTTIME;
+        {
                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
+                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
                 for ( TRIALS ) {
                         buckets[prng( prng ) % BUCKETS] += 1;           // sequential
                 } // for
                 avgstd( buckets );
+                avgstd( TRIALS, buckets );
                 free( buckets );
+        }
 …
         STARTTIME;
+        {
                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
                 for ( TRIALS ) {
+                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
+                for ( TRIALS / 5 ) {
                         buckets[prng() % BUCKETS] += 1;
                 } // for
                 avgstd( buckets );
+                avgstd( TRIALS / 5, buckets );
                 free( buckets );
+        }
         ENDTIME();
+        ENDTIME( " x 5 " );
         sout | nl | "Concurrent";
 …
                 } // wait for threads to complete
+        }
         ENDTIME();
+        ENDTIME( " x 5 " );
 #endif // 0
 #if 1

tests/attributes.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 15 13:53:31 2021
 // Update Count     : 38
+// Last Modified On : Thu Feb 23 20:33:07 2023
+// Update Count     : 39
 //
 …
 // aggregate_name
 struct __attribute__(( unused )) {} Dummy;
+static struct __attribute__(( unused )) {} Dummy;
 struct __attribute__(( unused )) Agn1;
 struct __attribute__(( unused )) Agn2 {};

tests/avltree/avl.h

-              r2ed94a9
+              rb110bcc
 // #include <lib.h>
+trait Comparable(T) {
+forall(T)
+trait Comparable {
   int ?<?(T, T);
 };

tests/concurrent/actors/.expect/types.txt

r2ed94a9	rb110bcc
12	12	-1
13	13	5
	14	nested inheritance actor test
	15	-1
	16	5
14	17	end

tests/concurrent/actors/dynamic.cfa

-              r2ed94a9
+              rb110bcc
 int Times = 1000000;                                                            // default values
+struct derived_actor {
+    inline actor;
+};
+void ?{}( derived_actor & this ) { ((actor &)this){}; }
+struct derived_actor { inline actor; };
 struct derived_msg {
     inline message;
 …
 void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
 Allocation receive( derived_actor & receiver, derived_msg & msg ) {
     if ( msg.cnt >= Times ) {
 …
     derived_actor * d_actor = alloc();
     (*d_actor){};
     *d_actor | *d_msg;
+    *d_actor << *d_msg;
     return Delete;
+}
 …
     derived_actor * d_actor = alloc();
     (*d_actor){};
     *d_actor | *d_msg;
+    *d_actor << *d_msg;
     printf("stopping\n");

tests/concurrent/actors/executor.cfa

-              r2ed94a9
+              rb110bcc
 };
 void ?{}( d_actor & this ) with(this) {
-    ((actor &)this){};
     id = ids++;
     gstart = (&this + (id / Set * Set - id)); // remember group-start array-element
 …
 struct d_msg { inline message; } shared_msg;
-void ?{}( d_msg & this ) { ((message &) this){ Nodelete }; }
 Allocation receive( d_actor & this, d_msg & msg ) with( this ) {
 …
     if ( recs % Batch == 0 ) {
         for ( i; Batch ) {
             gstart[sends % Set] | shared_msg;
+            gstart[sends % Set] << shared_msg;
             sends += 1;
+        }
 …
         } // switch
     executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true };
 …
         for ( i; Actors ) {
                 actors[i] | shared_msg;
+                actors[i] << shared_msg;
         } // for

tests/concurrent/actors/matrix.cfa

-              r2ed94a9
+              rb110bcc
 unsigned int xr = 500, xc = 500, yc = 500, Processors = 1; // default values
+struct derived_actor {
+    inline actor;
+};
+void ?{}( derived_actor & this ) { ((actor &)this){}; }
+struct derived_actor { inline actor; };
 struct derived_msg {
 …
 void ?{}( derived_msg & this ) {}
 void ?{}( derived_msg & this, int * Z, int * X, int ** Y ) {
     ((message &) this){ Finished };
+    ((message &) this){ Nodelete };
     this.Z = Z;
     this.X = X;
 …
         for ( unsigned int r = 0; r < xr; r += 1 ) {
                 actors[r] | messages[r];
+                actors[r] << messages[r];
         } // for

tests/concurrent/actors/pingpong.cfa

-              r2ed94a9
+              rb110bcc
 #include <actor.hfa>
+struct ping {
+    inline actor;
+};
+static inline void ?{}( ping & this ) { ((actor &)this){}; }
+struct pong {
+    inline actor;
+};
+static inline void ?{}( pong & this ) { ((actor &)this){}; }
+struct ping { inline actor; };
+struct pong { inline actor; };
 struct p_msg {
 …
     Allocation retval = Nodelete;
     if ( msg.count == times ) retval = Finished;
     *po | msg;
+    *po << msg;
     return retval;
+}
 …
     Allocation retval = Nodelete;
     if ( msg.count == times ) retval = Finished;
     *pi | msg;
+    *pi << msg;
     return retval;
+}
 …
     pi = &pi_actor;
     p_msg m;
     pi_actor | m;
+    pi_actor << m;
     stop_actor_system();

tests/concurrent/actors/static.cfa

-              r2ed94a9
+              rb110bcc
 int Times = 1000000;                                                            // default values
+struct derived_actor {
+    inline actor;
+};
+void ?{}( derived_actor & this ) { ((actor &)this){}; }
+struct derived_actor { inline actor; };
 struct derived_msg {
     inline message;
 …
 void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
 Allocation receive( derived_actor & receiver, derived_msg & msg ) {
     if ( msg.cnt >= Times ) {
 …
+    }
     msg.cnt++;
     receiver | msg;
+    receiver << msg;
     return Nodelete;
+}
 …
     derived_actor actor;
     actor | msg;
+    actor << msg;
     printf("stopping\n");

tests/concurrent/actors/types.cfa

-              r2ed94a9
+              rb110bcc
     int num;
 };
-static inline void ?{}( d_msg & this ) { ((message &)this){}; }
 // this isn't a valid receive routine since int is not a message type
 …
     inline actor;
 };
-static inline void ?{}( derived_actor2 & this ) { ((actor &)this){}; }
 Allocation receive( derived_actor2 & receiver, d_msg & msg ) {
 …
+}
+struct derived_actor3 {
+    inline actor;
+};
+static inline void ?{}( derived_actor3 & this ) { ((actor &)this){}; }
+struct derived_actor3 { inline actor; };
+struct derived_actor4 { inline derived_actor3; };
 struct d_msg2 {
     inline message;
     int num;
 };
-static inline void ?{}( d_msg2 & this ) { ((message &)this){}; }
 Allocation receive( derived_actor3 & receiver, d_msg & msg ) {
 …
     b.num = 1;
     c.num = 2;
     a | b | c;
+    a << b << c;
     stop_actor_system();
 …
     d_msg d_ac2_msg;
     d_ac2_msg.num = 3;
     d_ac2_0 | d_ac2_msg;
     d_ac2_1 | d_ac2_msg;
+    d_ac2_0 << d_ac2_msg;
+    d_ac2_1 << d_ac2_msg;
     stop_actor_system();
 …
         d_msg d_ac23_msg;
         d_ac23_msg.num = 4;
         d_ac3_0 | d_ac23_msg;
         d_ac2_2 | d_ac23_msg;
+        d_ac3_0 << d_ac23_msg;
+        d_ac2_2 << d_ac23_msg;
         stop_actor_system();
     } // RAII to clean up executor
 …
         b1.num = -1;
         c2.num = 5;
+        a3 | b1 | c2;
+        a3 << b1 << c2;
+        stop_actor_system();
+    } // RAII to clean up executor
+    {
+        printf("nested inheritance actor test\n");
+        executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
+        start_actor_system( Processors );
+        derived_actor4 a4;
+        d_msg b1;
+        d_msg2 c2;
+        b1.num = -1;
+        c2.num = 5;
+        a4 << b1 << c2;
         stop_actor_system();
     } // RAII to clean up executor

tests/concurrent/channels/parallel_harness.hfa

-              r2ed94a9
+              rb110bcc
 int test( size_t Processors, size_t Channels, size_t Producers, size_t Consumers, size_t ChannelSize ) {
     size_t Clusters = 1;
+    size_t Clusters = Processors;
     // create a cluster
     cluster clus[Clusters];
 …
+    }
     channels = anew( Channels );
+    channels = aalloc( Channels );
     // sout | "Processors: " | Processors | " ProdsPerChan: " | Producers | " ConsPerChan: " | Consumers | "Channels: " | Channels | " Channel Size: " | ChannelSize;
 …
     while( cons_done_count != Consumers * Channels ) {
         for ( i; Channels ) {
             if ( has_waiting_consumers( channels[i] ) ){
+            if ( has_waiters( channels[i] ) ){
                 #ifdef BIG
                 bigObject b{0};
 …
+    }
+    // for ( i; Channels ) {
+    //     // sout | get_count( channels[i] );
+    //     if ( get_count( channels[i] ) < Consumers ){
+    //         #ifdef BIG
+    //         bigObject b{0};
+    //         #endif
+    //         for ( j; Consumers ) {
+    //             #ifdef BIG
+    //             insert( channels[i], b );
+    //             #else
+    //             insert( channels[i], 0 );
+    //             #endif
+    //         }
+    //     }
+    // }
     sout | "cons";
     for ( i; Consumers * Channels ) {

tests/concurrent/pthread/.expect/bounded_buffer.x64.txt

r2ed94a9	rb110bcc
1		producer total value is ~~442~~80
2		consumer total value is ~~442~~80
	1	producer total value is 39780
	2	consumer total value is 39780

tests/concurrent/pthread/.expect/bounded_buffer.x86.txt

r2ed94a9	rb110bcc
1		producer total value is ~~4506~~0
2		consumer total value is ~~4506~~0
	1	producer total value is 1770
	2	consumer total value is 1770

tests/concurrent/signal/disjoint.cfa

r2ed94a9	rb110bcc
38	38
39	39	// Use a global struct because the order needs to match with Signaller thread
40		struct {
	40	static struct {
41	41	global_t mut;
42	42	global_data_t data;

tests/concurrent/waitfor/parse.cfa

-              r2ed94a9
+              rb110bcc
 //----------------------------------------------------------------------------------------
 //----------------------------------------------------------------------------------------
+//
+// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 //
+//              DEPRECATED TEST
+//              DIFFERS BETWEEN DEBUG AND RELEASE
+//
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// waitfor.c --
+//
+// Author           : Peter A. Buhr
+// Created On       : Wed Aug 30 17:53:29 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 22:52:18 2023
+// Update Count     : 64
+//
 #include <monitor.hfa>
 …
 monitor M {};
+M a;
+void f1( M & mutex a );
+void f2( M & mutex a );
+void f2( M & mutex a, M & mutex b );
+void f3( M & mutex a );
+void f3( M & mutex a, M & mutex b );
+void f3( M & mutex a, M & mutex b, M & mutex c );
+void foo() {
+        //---------------------------------------
+        waitfor( f1 : a ) {
+;
+        }
+        //---------------------------------------
+        waitfor( f1 : a ) {
+;
+        }
+        waitfor( f2 : a ) {
+;
+        }
+        //---------------------------------------
+        when( 1 < 3 ) waitfor( f2 : a, a ) {
+;
+        }
+        or timeout( 100 ) {
+;
+        }
+        //---------------------------------------
+        when( 2 < 3 ) waitfor( f3 : a ) {
+;
+        }
+void notcalled( M & mutex m1, M & mutex m2 ) {
+        abort();
+}
+void or( M & mutex m ) {
+        abort();
+}
+void timeout( M & mutex m ) {
+        abort();
+}
+void fred( M & mutex m, M & mutex or, M & mutex timeout ) {
+        // test waitfor and when
+        waitfor( notcalled : m, m );
+        waitfor( notcalled : m, m ) {
+        }
+        waitfor( notcalled : m, m ) {
+        }
+        when( true ) waitfor( notcalled : m, m );
+        when( true ) waitfor( notcalled : m, m ) {
+        }
+        waitfor( notcalled : m, m );
+        or waitfor( notcalled : m, m );
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) waitfor( notcalled : m, m );
+        waitfor( notcalled : m, m ) {
+        } or waitfor( notcalled : m, m ) {
+        }
+        waitfor( notcalled : m, m ) {
+        } or waitfor( notcalled : m, m ) {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when( true ) waitfor( notcalled : m, m ) {
+        }
+        waitfor( notcalled : m, m );
+        or waitfor( notcalled : m, m ) {
+        }
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) waitfor( notcalled : m, m ) {
+        }
+        waitfor( notcalled : m, m ) {
+        } or waitfor( notcalled : m, m );
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when( true ) waitfor( notcalled : m, m );
+        // test when, waitfor and else
+        waitfor( notcalled : m, m );
+        or else;
+        when( true ) waitfor( notcalled : m, m );
+        or else;
+        when( true ) waitfor( notcalled : m, m );
+        or else;
+        waitfor( notcalled : m, m ) {
+        } or else {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or else {
+        }
+        waitfor( notcalled : m, m );
         or else {
+;
+        }
+        //---------------------------------------
+        when( 3 < 3 ) waitfor( f3 : a, a ) {
+;
+        }
+        or when( 4 < 3 ) timeout( 101 ) {
+;
+        }
+        or when( 5 < 3 ) else {
+;
+        }
+        //---------------------------------------
+        when( 6 < 3 ) waitfor( f3 : a, a, a ) {
+;
+        }
+        or when( 7 < 3 ) waitfor( f1 : a  ) {
+;
+        }
+        }
+        when( true ) waitfor( notcalled : m, m );
         or else {
+;
+        }
+        //---------------------------------------
+        when( 8 < 3 ) waitfor( f3 : a, a ) {
+;
+        }
+        or waitfor( f1 : a  ) {
+;
+        }
+        or when( 9 < 3 ) timeout( 102 ) {
+;
+        }
+        //---------------------------------------
+        when( 10 < 3 ) waitfor( f1 : a ) {
+;
+        }
+        or waitfor( f2 : a, a ) {
+;
+        }
+        or timeout( 103 ) {
+;
+        }
+        or when( 11 < 3 ) else {
+;
+        }
+}
+int main() {}
+        }
+        when( true ) waitfor( notcalled : m, m );
+        or else {
+        }
+        waitfor( notcalled : m, m ) {
+        } or else;
+        when( true ) waitfor( notcalled : m, m ) {
+        } or else;
+        waitfor( notcalled : m, m );
+        or when( true ) else;
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) else;
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) else;
+        waitfor( notcalled : m, m ) {
+        } or when( true ) else {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when( true ) else {
+        }
+        waitfor( notcalled : m, m );
+        or when( true ) else {
+        }
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) else {
+        }
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) else {
+        }
+        waitfor( notcalled : m, m ) {
+        } or when( true ) else;
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when( true ) else;
+        // test when, waitfor and timeout
+        waitfor( notcalled : m, m );
+        or timeout( 3 );
+        waitfor( notcalled : m, m );
+        or timeout( 3 );
+        when( true ) waitfor( notcalled : m, m );
+        or timeout( 3 );
+        waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when ( true ) timeout( 3 ) {
+        }
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when ( true ) timeout( 3 ) {
+        }
+        waitfor( notcalled : m, m );
+        or timeout( 3 ) {
+        }
+        when( true ) waitfor( notcalled : m, m );
+        or timeout( 3 ) {
+        }
+        when( true ) waitfor( notcalled : m, m );
+        or when( true ) timeout( 3 ) {
+        }
+        waitfor( notcalled : m, m ) {
+        } or timeout( 3 );
+        when( true ) waitfor( notcalled : m, m ) {
+        } or timeout( 3 );
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when( true ) timeout( 3 );
+        // test when, waitfor, timeout and else
+        waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        } or when( true ) else {}
+        when( true ) waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        } or when( true ) else {}
+        waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        } or when( true ) else {}
+        waitfor( notcalled : m, m ) {
+        } or when( true ) timeout( 3 ) {
+        } or when( true ) else {}
+        when( true ) waitfor( notcalled : m, m ) {
+        } or timeout( 3 ) {
+        } or when( true ) else {}
+        waitfor( notcalled : m, m ) {
+        } or when( true ) timeout( 3 ) {
+        } or when( true ) else {}
+        when( true ) waitfor( notcalled : m, m ) {
+        } or when( true ) timeout( 3 ) {
+        } or when( true ) else {}
+        // test quasi-keywords "or" and "timeout"
+        int or = 0, timeout = 0;
+        waitfor( timeout : timeout ) timeout += 1; or timeout( timeout );
+        waitfor( notcalled : or, or ) or += 1; or timeout( or ) 3;
+        when( or ) waitfor( or : m ) { 4; } or timeout( or ) or += 1;
+        when( timeout ) waitfor( notcalled : timeout, timeout ) or += 1; or else timeout += 1;
+        when( or + timeout ) waitfor( or : m ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout += 1;
+        when( 3 ) waitfor( or : or ) 3; or when( or ) waitfor( notcalled : or, or ) 4; or else 4;
+        when( timeout ) waitfor( or : timeout ) 3; or waitfor( notcalled : timeout, or ) 4; or when( or ) timeout( timeout ) 4;
+        when( 3 ) waitfor( or : timeout ) or += 1;
+        or waitfor( or : or ) timeout += 1;
+        or timeout( timeout ) or += 1;
+        or when( 3 ) else or += 1;
+        // test else selection
+        if ( or > timeout ) waitfor( or : or ) 3;
+        else waitfor( timeout : timeout ) 4;
+}
+//Dummy main
+int main( int argc, char const * argv[] ) {
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa waitfor.cfa" //
+// End: //

tests/declarationSpecifier.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed Aug 17 08:21:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 30 18:20:36 2019
 // Update Count     : 4
+// Last Modified On : Thu Feb 23 20:53:31 2023
+// Update Count     : 8
 //
 …
 short int volatile static const x8;
+const volatile struct { int i; } x10;
+const struct { int i; } volatile x11;
+struct { int i; } const volatile x12;
+static const volatile struct { int i; } x13;
+const static struct { int i; } volatile x14;
+struct { int i; } static const volatile x15;
+struct { int i; } const static volatile x16;
+struct { int i; } const volatile static x17;
+static const volatile struct { int i; } x10;
+static const struct { int i; } volatile x11;
+static struct { int i; } const volatile x12;
+const static struct { int i; } volatile x13;
+struct { int i; } static const volatile x14;
+struct { int i; } const static volatile x15;
+struct { int i; } const volatile static x16;
 const Int volatile x20;
 …
 Int volatile static const x27;
+const volatile struct { Int i; } x29;
+const struct { Int i; } volatile x30;
+struct { Int i; } const volatile x31;
+static const volatile struct { Int i; } x32;
+const static struct { Int i; } volatile x33;
+struct { Int i; } static const volatile x34;
+struct { Int i; } const static volatile x35;
+struct { Int i; } const volatile static x36;
+static const volatile struct { Int i; } x29;
+static const struct { Int i; } volatile x30;
+static struct { Int i; } const volatile x31;
+const static struct { Int i; } volatile x32;
+struct { Int i; } static const volatile x33;
+struct { Int i; } const static volatile x34;
+struct { Int i; } const volatile static x35;
 _Thread_local int x37;

tests/errors/.expect/declaration.txt

-              r2ed94a9
+              rb110bcc
 errors/declaration.cfa:16:1 error: duplicate static in declaration of x1: static const volatile short int
+errors/declaration.cfa:16:1 error: duplicate static storage class(es) in declaration of x1: static const volatile short int
 errors/declaration.cfa:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
+errors/declaration.cfa:17:1 error: conflicting extern & static storage classes in declaration of x2: extern const volatile short int
 errors/declaration.cfa:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
+errors/declaration.cfa:18:1 error: conflicting extern & auto storage classes, conflicting extern & static storage classes, conflicting extern & static storage classes, duplicate extern storage class(es) in declaration of x3: extern const volatile short int
 errors/declaration.cfa:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
+errors/declaration.cfa:19:1 error: duplicate static storage class(es) in declaration of x4: static const volatile instance of const volatile struct __anonymous0
   with members
     i: int
 …
 errors/declaration.cfa:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
+errors/declaration.cfa:20:1 error: duplicate const qualifier(s), duplicate static storage class(es), duplicate volatile qualifier(s) in declaration of x5: static const volatile instance of const volatile struct __anonymous1
   with members
     i: int
 …
 errors/declaration.cfa:22:1 error: duplicate static in declaration of x6: static const volatile Int
+errors/declaration.cfa:22:1 error: duplicate static storage class(es) in declaration of x6: static const volatile Int
 errors/declaration.cfa:24:1 error: duplicate const in declaration of f01: static inline function
+errors/declaration.cfa:24:1 error: duplicate const qualifier(s) in declaration of f01: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:25:1 error: duplicate volatile in declaration of f02: static inline function
+errors/declaration.cfa:25:1 error: duplicate volatile qualifier(s) in declaration of f02: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:26:1 error: duplicate const in declaration of f03: static inline function
+errors/declaration.cfa:26:1 error: duplicate const qualifier(s) in declaration of f03: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:27:1 error: duplicate volatile in declaration of f04: static inline function
+errors/declaration.cfa:27:1 error: duplicate volatile qualifier(s) in declaration of f04: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:28:1 error: duplicate const in declaration of f05: static inline function
+errors/declaration.cfa:28:1 error: duplicate const qualifier(s) in declaration of f05: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:29:1 error: duplicate volatile in declaration of f06: static inline function
+errors/declaration.cfa:29:1 error: duplicate volatile qualifier(s) in declaration of f06: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:30:1 error: duplicate const in declaration of f07: static inline function
+errors/declaration.cfa:30:1 error: duplicate const qualifier(s) in declaration of f07: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
+errors/declaration.cfa:31:1 error: duplicate const volatile qualifier(s) in declaration of f08: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
+errors/declaration.cfa:33:1 error: duplicate const volatile qualifier(s) in declaration of f09: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
+errors/declaration.cfa:34:1 error: duplicate const qualifier(s), duplicate _Atomic qualifier(s), duplicate _Atomic qualifier(s), duplicate const restrict volatile qualifier(s) in declaration of f09: static inline function
   with no parameters
   returning const restrict volatile _Atomic int

tests/forall.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed May  9 08:48:15 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb  5 07:54:43 2023
 // Update Count     : 90
+// Last Modified On : Thu Feb 23 20:29:59 2023
+// Update Count     : 91
 //
 …
 forall( T ) struct S { T t; } (int) x, y, z;
 forall( T ) struct { T t; } (int) a, b, c;
+static forall( T ) struct { T t; } (int) a, b, c;
 forall( T ) static forall( S ) {

tests/function-operator.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Fri Aug 25 15:21:11 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 11 18:27:45 2019
 // Update Count     : 10
+// Last Modified On : Sat Feb 25 07:26:10 2023
+// Update Count     : 12
 //
 …
 // STL-like Algorithms
+trait Assignable(T &, U &) { T ?=?(T &, U); };
+trait Copyable(T &) { void ?{}(T &, T); };
+trait Destructable(T &) { void ^?{}(T &); };
+forall(T &, U &)
+trait Assignable { T ?=?(T &, U); };
+forall(T &)
+trait Copyable { void ?{}(T &, T); };
+forall(T &)
+trait Destructable { void ^?{}(T &); };
 trait Iterator(iter & | sized(iter) | Copyable(iter) | Destructable(iter), T) {

tests/include/includes.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 22 08:27:20 2022
 // Update Count     : 779
+// Last Modified On : Wed Feb 22 10:16:58 2023
+// Update Count     : 811
 //
 …
 #include <gshadow.h>
 #include <iconv.h>
+#include <ifaddrs.h>
+//#include <ifaddrs.h>                                                                  // causes warning messages that break the build
 #include <inttypes.h>
 #include <langinfo.h>
 …
 #include <ncurses_dll.h>                                                                // may not be installed, comes with ncurses
 #endif
 #include <netdb.h>
+//#include <netdb.h>
 #include <nl_types.h>
 #include <nss.h>
 …
 #include <pwd.h>
 #include <regex.h>
 #include <resolv.h>
+//#include <resolv.h>
 #include <re_comp.h>
 #include <sched.h>
 …
 #endif // __CFA__
 int main( int argc, char const * argv[] ) {
+int main() {
     #pragma GCC warning "Compiled"                                                      // force non-empty .expect file, NO TABS!!!
+}

tests/io/comp_basic.cfa

-              r2ed94a9
+              rb110bcc
 #include <unistd.h>
 struct {
+static struct {
         barrier & bar;
         int pipe[2];
 } globals;

tests/io/comp_fair.cfa

-              r2ed94a9
+              rb110bcc
 #include <unistd.h>
 struct {
+static struct {
         barrier & bar;
         int pipe[2];
 } globals;

tests/linking/mangling/header.hfa

-              r2ed94a9
+              rb110bcc
 extern name_but_a_typedefed_t a_typedefed_global;
+extern struct /* anonymous */ {
+        int some_int;
+        int some_other_int;
+} a_global_with_no_type;
+// Must be extern C to prevent name mangling.
+extern "C" {
+        extern struct /* anonymous */ {
+                int some_int;
+                int some_other_int;
+        } a_global_with_no_type;
+}

tests/linking/mangling/lib.cfa

-              r2ed94a9
+              rb110bcc
 name_but_a_typedefed_t a_typedefed_global;
+struct {
+        int some_int;
+        int some_other_int;
+} a_global_with_no_type;
+// Must be extern C to prevent name mangling.
+extern "C" {
+        // This declaration is necessary to create an instance of a_global_with_no_type.
+        // typeof is a trick to get a_global_with_no_type's type because its type is anonymous.
+        // Otherwise C generates conflicting types for a_global_with_no_type in .h and .c
+        // because C uses name equivalence and the two anonymous types cannot have the same name.
+        typeof(a_global_with_no_type) a_global_with_no_type;
+}

tests/linking/mangling/main.cfa

-              r2ed94a9
+              rb110bcc
 #include <fstream.hfa>
 struct { int a; } test; //purposefully before the include
+static struct { int a; } test; // purposefully before the include to force anonymous name numbering
 #include "header.hfa"
 …
         sout | "Done!";
-        return 0;
+}

tests/pybin/settings.py

-              r2ed94a9
+              rb110bcc
         global archive
         global install
+        global invariant
         global continue_
 …
         all_install  = [Install(o)      for o in list(dict.fromkeys(options.install))]
         archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
+        invariant    = options.invariant
         continue_    = options.continue_
         dry_run      = options.dry_run # must be called before tools.config_hash()

tests/quotedKeyword.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  7 19:07:07 2020
 // Update Count     : 25
+// Last Modified On : Thu Feb 23 20:31:05 2023
+// Update Count     : 26
 //
 #include <fstream.hfa>
 struct {
+static struct {
         int ``otype;
         int ``struct;

tests/sum.cfa

-              r2ed94a9
+              rb110bcc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  5 21:27:25 2021
 // Update Count     : 346
+// Last Modified On : Fri Feb 24 22:52:12 2023
+// Update Count     : 347
 //
 …
 #include <stdlib.hfa>
+trait sumable( T ) {
+forall( T )
+trait sumable {
         void ?{}( T &, zero_t );                                                        // 0 literal constructor
         void ?{}( T &, one_t );                                                         // 1 literal constructor

tests/test.py

-              r2ed94a9
+              rb110bcc
         parser.add_argument('--install', help='Run all tests based on installed binaries or tree binaries', type=comma_separated(yes_no), default='no')
         parser.add_argument('--continue', help='When multiple specifications are passed (debug/install/arch), sets whether or not to continue if the last specification failed', type=yes_no, default='yes', dest='continue_')
+        parser.add_argument('--invariant', help='Tell the compiler to check invariants while running.', action='store_true')
         parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=180)
         parser.add_argument('--global-timeout', help='Maximum cumulative duration in seconds after the ALL tests are considered to have timed out', type=int, default=7200)
 …
         test.prepare()
+        # extra flags for cfa to pass through make.
+        cfa_flags = 'CFAFLAGS=--invariant' if settings.invariant else None
         # ----------
         # MAKE
 …
         # build, skipping to next test on error
         with Timed() as comp_dur:
                 make_ret, _, _ = make( test.target(), output_file=subprocess.DEVNULL, error=out_file, error_file = err_file )
+                make_ret, _, _ = make(test.target(), flags=cfa_flags, output_file=subprocess.DEVNULL, error=out_file, error_file=err_file)
         # ----------

Context Navigation

Legend: