Changeset f7e4f8e8

Timestamp:

Oct 30, 2020, 12:36:16 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

0ab3b73, 36d0a80

Parents:

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

Message:

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

Files:

• Jenkinsfile (modified) (4 diffs)
• benchmark/readyQ/cycle.cfa (added)
• benchmark/readyQ/cycle.cpp (added)
• benchmark/readyQ/cycle.go (added)
• benchmark/readyQ/rq_bench.hfa (added)
• benchmark/rmit.py (added)
• doc/papers/concurrency/mail2 (modified) (2 diffs)
• doc/proposals/vtable.md (modified) (1 diff)
• doc/theses/andrew_beach_MMath/thesis-frontpgs.tex (modified) (3 diffs)
• doc/theses/andrew_beach_MMath/uw-ethesis.cls (modified) (5 diffs)
• libcfa/prelude/builtins.c (modified) (1 diff)
• libcfa/src/concurrency/coroutine.cfa (modified) (6 diffs)
• libcfa/src/concurrency/exception.cfa (modified) (3 diffs)
• libcfa/src/concurrency/exception.hfa (modified) (2 diffs)
• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• libcfa/src/concurrency/io/setup.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel.cfa (modified) (6 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (2 diffs)
• libcfa/src/concurrency/monitor.cfa (modified) (1 diff)
• libcfa/src/concurrency/thread.cfa (modified) (4 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (3 diffs)
• libcfa/src/exception.c (modified) (3 diffs)
• libcfa/src/exception.h (modified) (4 diffs)
• libcfa/src/stdhdr/unwind.h (added)
• src/AST/Convert.cpp (modified) (19 diffs)
• src/AST/Decl.cpp (modified) (1 diff)
• src/AST/Decl.hpp (modified) (1 diff)
• src/AST/DeclReplacer.cpp (modified) (3 diffs)
• src/AST/DeclReplacer.hpp (modified) (1 diff)
• src/AST/Expr.cpp (modified) (4 diffs)
• src/AST/Expr.hpp (modified) (6 diffs)
• src/AST/Fwd.hpp (modified) (1 diff)
• src/AST/Node.hpp (modified) (1 diff)
• src/AST/Pass.hpp (modified) (5 diffs)
• src/AST/Pass.impl.hpp (modified) (8 diffs)
• src/AST/SymbolTable.cpp (modified) (1 diff)
• src/AST/SymbolTable.hpp (modified) (1 diff)
• src/AST/TranslationUnit.hpp (added)
• src/AST/Type.cpp (modified) (1 diff)
• src/AST/Type.hpp (modified) (3 diffs)
• src/AST/porting.md (modified) (5 diffs)
• src/Common/PassVisitor.h (modified) (2 diffs)
• src/Common/PassVisitor.impl.h (modified) (6 diffs)
• src/Common/utility.h (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (9 diffs)
• src/GenPoly/GenPoly.cc (modified) (9 diffs)
• src/GenPoly/GenPoly.h (modified) (4 diffs)
• src/GenPoly/Specialize.cc (modified) (1 diff)
• src/InitTweak/FixGlobalInit.cc (modified) (5 diffs)
• src/InitTweak/FixGlobalInit.h (modified) (2 diffs)
• src/InitTweak/FixInit.cc (modified) (2 diffs)
• src/InitTweak/FixInit.h (modified) (2 diffs)
• src/InitTweak/FixInitNew.cpp (added)
• src/InitTweak/GenInit.cc (modified) (1 diff)
• src/InitTweak/GenInit.h (modified) (1 diff)
• src/InitTweak/InitTweak.cc (modified) (7 diffs)
• src/InitTweak/InitTweak.h (modified) (4 diffs)
• src/InitTweak/module.mk (modified) (1 diff)
• src/Parser/ParseNode.h (modified) (6 diffs)
• src/Parser/StatementNode.cc (modified) (2 diffs)
• src/Parser/parser.yy (modified) (5 diffs)
• src/ResolvExpr/Resolver.cc (modified) (5 diffs)
• src/ResolvExpr/Resolver.h (modified) (1 diff)
• src/SymTab/Autogen.cc (modified) (2 diffs)
• src/SymTab/Autogen.h (modified) (1 diff)
• src/SynTree/Expression.h (modified) (2 diffs)
• src/main.cc (modified) (1 diff)
• tests/.expect/const-init.txt (modified) (1 diff)
• tests/complex.cfa (modified) (1 diff)
• tests/const-init.cfa (modified) (2 diffs)
• tests/exceptions/cancel/.expect/thread.txt (added)
• tests/exceptions/cancel/coroutine.cfa (modified) (1 diff)
• tests/exceptions/cancel/thread.cfa (added)
• tests/exceptions/conditional.cfa (modified) (1 diff)
• tests/exceptions/except-io.hfa (modified) (1 diff)
• tests/exceptions/trash.cfa (modified) (1 diff)
• tests/global-monomorph.cfa (modified) (1 diff)
• tests/poly-d-cycle.cfa (modified) (1 diff)
• tests/poly-o-cycle.cfa (modified) (1 diff)

Jenkinsfile

@@ -127 +127 @@
                         }
 
-                        sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} --quiet --prefix=${BuildDir}"
+                        ast = Settings.NewAST ? "--enable-new-ast" : "--disable-new-ast"
+
+                        sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} ${ast} --quiet --prefix=${BuildDir}"
 
                         // Configure libcfa
@@ -359 +361 @@
         public final CC_Desc Compiler
         public final Arch_Desc Architecture
+        public final Boolean NewAST
         public final Boolean RunAllTests
         public final Boolean RunBenchmark
@@ -410 +413 @@
 
                 this.IsSandbox          = (branch == "jenkins-sandbox")
+                this.NewAST             = param.NewAST
                 this.RunAllTests        = param.RunAllTests
                 this.RunBenchmark       = param.RunBenchmark
@@ -470 +474 @@
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
+                                        description: 'If true, build compiler using new AST',           \
+                                        name: 'NewAST',                                                                         \
+                                        defaultValue: false,                                                            \
+                                ],                                                                                              \
+                                [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If false, only the quick test suite is ran',              \
                                         name: 'RunAllTests',                                                            \
                                         defaultValue: false,                                                            \
-                                ],                                                                                              \
+                                ],
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins also runs benchmarks',           \

doc/papers/concurrency/mail2

@@ +1 @@
+
 Date: Wed, 26 Jun 2019 20:12:38 +0000
 From: Aaron Thomas <onbehalfof@manuscriptcentral.com>
@@ -1074 +1075 @@
 Software: Practice and Experience Editorial Office
 
+
+
+Date: Thu, 15 Oct 2020 13:48:52 +0000
+From: Richard Jones <onbehalfof@manuscriptcentral.com>
+Reply-To: R.E.Jones@kent.ac.uk
+To: tdelisle@uwaterloo.ca, pabuhr@uwaterloo.ca
+Subject: Software: Practice and Experience - Decision on Manuscript ID
+ SPE-19-0219.R3
+
+15-Oct-2020
+
+Dear Dr Buhr,
+
+It is a pleasure to accept your manuscript entitled "Advanced Control-flow and Concurrency in Cforall" in its current form for publication in Software: Practice and Experience.  
+
+Please note although the manuscript is accepted the files will now be checked to ensure that everything is ready for publication, and you may be contacted if final versions of files for publication are required.
+
+Your article cannot be published until the publisher has received the appropriate signed license agreement. Within the next few days the corresponding author will receive an email from Wiley's Author Services system which will ask them to log in and will present them with the appropriate license for completion.
+
+Thank you for your fine contribution.
+
+Sincerely,
+Richard
+
+Prof. Richard Jones
+Editor, Software: Practice and Experience
+R.E.Jones@kent.ac.uk
+
+P.S. - You can help your research get the attention it deserves! Check out Wiley's free Promotion Guide for best-practice recommendations for promoting your work at www.wileyauthors.com/eeo/guide. And learn more about Wiley Editing Services which offers professional video, design, and writing services to create shareable video abstracts, infographics, conference posters, lay summaries, and research news stories for your research at www.wileyauthors.com/eeo/promotion.
+
+This journal accepts artwork submissions for Cover Images. This is an optional service you can use to help increase article exposure and showcase your research. For more information, including artwork guidelines, pricing, and submission details, please visit the Journal Cover Image page at www.wileyauthors.com/eeo/covers. If you want help creating an image, Wiley Editing Services offers a professional cover image design service that creates eye-catching images, ready to be showcased on the journal cover at www.wileyauthors.com/eeo/design.
+
+
+
+Date: Fri, 16 Oct 2020 12:44:42 +0000
+From: Mayank Roy Chowdhury <onbehalfof@manuscriptcentral.com>
+Reply-To: speoffice@wiley.com
+To: pabuhr@uwaterloo.ca
+Subject: Manuscript Accepted - Please submit final updates to SPE-19-0219.R3 [email ref: ENR-AW-1-c]
+
+16-Oct-2020
+
+Dear Dr. Buhr,
+
+Manuscript id: SPE-19-0219.R3
+Manuscript title: Advanced Control-flow and Concurrency in Cforall
+
+Although your manuscript has been accepted for publication it is now being returned to your author center for you to review and make any final adjustments or corrections prior to production and publication.
+
+Any special instructions will be listed below:
+1) Funding Information added in ScholorOne but missing in main document, Kindly add the Funding information in main document.
+2) Please provide the clean version of the manuscript without any highlights or tracked changes.
+3) Kindly check and make sure citations for all figures and Tables are present in the main document
+
+Please now log back into your Scholar One Author Center and click on the "Manuscripts Accepted for First Look" queue. In order to update the submission, click on the "submit updated manuscript" link in the "Actions" column and follow the steps as you would during a manuscript submission process.
+
+On the File Upload screen please upload the FINAL versions of all the files, including print quality image files. For information about image quality requirements, please refer to the guidelines at https://authorservices.wiley.com/asset/photos/electronic_artwork_guidelines.pdf.
+
+Instructions for uploading replacement files:
+1. On the "File Upload" step, click on the "edit" button for the file you wish to replace.
+2. In the "Upload a later version" section, browse to locate the replacement final version.
+3. Add any comments concerning the replacement (e.g. "high res image").
+4. Select whether the new file is a minor or major version (we suggest you select minor version)
+5. Click upload.
+6. Click 'Submit' when all the files have been uploaded and you will receive an automated email to say that submission is successful.
+
+Please submit your updates within the next 7 days to ensure there are no unnecessary delays in production.
+
+Sincerely,
+Software: Practice and Experience Editorial Office
+
+
+
+From: SPE Office <speoffice@wiley.com>
+To: "Peter A. Buhr" <pabuhr@uwaterloo.ca>
+Subject: Re: Manuscript Accepted - Please submit final updates to SPE-19-0219.R3 [email ref: ENR-AW-1-c]
+Date: Mon, 19 Oct 2020 17:04:24 +0000
+
+Dear Dr. Buhr,
+
+Thank you very much for contacting the Editorial Office.
+
+I would like to let you know that the files has been found in order and moved to production.
+
+Plesae let me know for further assistance in this regard.
+
+Best Regards
+
+Mayank Roy Chowdhury
+Editorial Assistant
+Software practice and Experience
+________________________________
+From: Peter A. Buhr <pabuhr@uwaterloo.ca>
+Sent: Sunday, October 18, 2020 2:00 PM
+To: SPE Office <speoffice@wiley.com>
+Cc: Thierry Delisle <tdelisle@uwaterloo.ca>
+Subject: Re: Manuscript Accepted - Please submit final updates to SPE-19-0219.R3 [email ref: ENR-AW-1-c]
+
+       This is an external email.
+
+    Mayank Roy Chowdhury <onbehalfof@manuscriptcentral.com> writes:
+
+    Instructions for uploading replacement files:
+    1. On the "File Upload" step, click on the "edit" button for the file you wish to replace.
+    2. In the "Upload a later version" section, browse to locate the replacement final version.
+    3. Add any comments concerning the replacement (e.g. "high res image").
+    4. Select whether the new file is a minor or major version (we suggest you select minor version)
+    5. Click upload.
+    6. Click 'Submit' when all the files have been uploaded and you will receive an automated email to say that submission is successful.
+
+There was no "edit" button on the "File Upload" page, so I just upload the
+final version of the PDF and source files using the mechanism on the "File
+Upload" page and submitted that.
+
+
+
+Date: Tue, 20 Oct 2020 13:28:37 +0530
+To: "Dr. Peter Buhr" <pabuhr@uwaterloo.ca>
+From: jpcms@spi-global.com
+Subject: Information: Production Editor Contact Software:Practice and Experience  | Advanced Control-flow and Concurrency in C A
+
+Dear Dr. Peter Buhr,
+
+We are in the process of preparing "Advanced Control-flow and Concurrency in C A" for publication. Your production editor, Joel Pacaanas, will support you and your article throughout the process.
+
+Please get in touch with your Production Editor at SPEproofs@wiley.com;EllaMae.Navor@spi-global.com if you have any questions.
+                
+Sincerely,
+Booking-in Team,
+On behalf of Wiley
+
+Article ID: SPE_2925
+Article DOI: 10.1002/SPE.2925
+
+
+
+Date: Tue, 20 Oct 2020 10:33:04 +0000
+From: <cs-author@wiley.com>
+To: <pabuhr@uwaterloo.ca>
+Subject: In Production: Your article accepted in Software: Practice and Experience
+
+Dear Peter Buhr,
+
+Article ID: SPE2925
+Article DOI: 10.1002/spe.2925
+Internal Article ID: 16922213
+Article: Advanced Control-flow and Concurrency in C A
+Journal: Software: Practice and Experience
+
+Congratulations on the acceptance of your article for publication in Software: Practice and Experience. 
+
+Your article has been received and the production process is now underway. We look forward to working with you and publishing your article. Using Wiley Author Services, you can track your article's progress.
+
+Please click below to login - if you are using a different email address than this one, you will need to manually assign this article to your Dashboard (see https://hub.wiley.com/docs/support/assigning-a-missing-article-to-my-dashboard-DOC-11871?utm_source=new%20user%20invitation&utm_medium=email How do I assign a missing article to My Dashboard?): 
+
+https://authorservices.wiley.com/index.html#login?campaign=email_invitation-new
+
+If applicable, a list of available actions will appear below - check out your Author Services Dashboard for all actions related to your articles.
+
+Sign your license agreement (REQUIRED)  -- you will receive an email when this task is ready on your dashboard. Track your article's progress to publicationAccess your published articleInvite colleagues to view your published article
+If you need any assistance, please click http://www.wileyauthors.com/help?utm_source=new%20user%20invitation&utm_medium=email here to view our Help section.
+
+Sincerely,
+Wiley Author Services
+
+P.S. - Some journals accept artwork submissions for Cover Images. This is an optional service you can use to help increase article exposure and showcase your research. Pricing and placement options vary by journal. For more information, including artwork guidelines, pricing, and submission details, please visit the https://authorservices.wiley.com/author-resources/Journal-Authors/Promotion/journal-cover-image.html?utm_source=as&utm_medium=email&utm_term=invitation_msg&utm_content=covers&utm_campaign=2019feb?campaign=email_invitation-new" target=_blank">Journal Cover Image page. If you want help creating an image, Wiley Editing Services offers a professional https://wileyeditingservices.com/en/article-promotion/cover-image-design.html?utm_source=as&utm_medium=email&utm_term=ie&utm_content=cid&utm_campaign=prodops" target=_blank">Cover Image Design service that creates eye-catching images, ready to be showcased on the journal cover.
+
+
+
+Date: Thu, 22 Oct 2020 20:21:49 +0000
+From: <cs-author@wiley.com>
+To: <pabuhr@uwaterloo.ca>
+Subject: You have actions to complete in Author Services
+
+Dear Peter Buhr,
+
+Article ID: SPE2925
+Article DOI: 10.1002/spe.2925
+Internal Article ID: 16922213
+Article: Advanced Control-flow and Concurrency in C A
+Journal: Software: Practice and Experience
+
+For the above article, you have the following open tasks:
+
+Sign your license agreement in order to publish your article. Simply click the Sign License button on your https://authorservices.wiley.com?campaign=email_license-notice1">Wiley Author Services Dashboard.
+
+Need any help? Please visit our https://authorsupport.wiley.com/s/">Author Support Center. 
+
+Sincerely,
+Wiley Author Services
+
+
+
+Date: Thu, 22 Oct 2020 23:13:07 +0000
+From: <cs-author@wiley.com>
+To: <pabuhr@uwaterloo.ca>
+Subject: License was successfully submitted! Thank you!
+
+Dear Peter Buhr,                                                                  
+
+Article ID: SPE2925
+Article DOI: 10.1002/spe.2925
+Internal Article ID: 16922213
+Article: Advanced Control-flow and Concurrency in C A  
+Journal: Software: Practice and Experience                                                                      
+                                                                          
+You've successfully completed license signing for your article - thank you! You can view your signed agreement at any time by visiting your https://authorservices.wiley.com?campaign=email_license-confirm">Wiley Author Services Dashboard.                                                                      
+
+Sincerely,                                                                                 
+
+Wiley Author Services

doc/proposals/vtable.md

@@ -512 +512 @@
 possibly like the one used to create the assertion.
 
+### Extension: Associated Types Use
+If the `associated_types.md` proposal is accepted the following trait could
+be added:
+
+    trait is_virtual(dtype T) {
+        dtype table;
+        // An example assertion:
+        const table & get_virtual_table(T &);
+    }
+
+There may be more assertions but there has to be at least one way to find
+the (possibly default) virtual table. It is required to construct instances
+of the type.
+
+Without the assotiated type it would look like this:
+
+    trait is_virtual(dtype T, dtype table) {
+        const table & get_virtual_table(T &);
+    }
+
+Which is just a little bit longer to use but becomes more problematic if the
+user has to explicately provide the table's name as it doesn't really have its
+own type name. If it does it is probably mangled.
+
 ### Virtual Tables as Types
 Here we consider encoding plus the implementation of functions on it to be a

doc/theses/andrew_beach_MMath/thesis-frontpgs.tex

@@ -5 +5 @@
 % TITLE PAGE
 %----------------------------------------------------------------------
+
+% Slowly generalizing.
+\ethesissetup{
+  author=Pat Neugraad,%
+  title={University of Waterloo E-Thesis Template for \LaTeX},
+  degree=phd,%
+  program=Zoology,%
+}
 
 \pagestyle{empty}
@@ -15 +23 @@
         \vspace*{1.0cm}
 
-        \Huge
-        {\bf University of Waterloo E-Thesis Template for \LaTeX }
-
-        \vspace*{1.0cm}
-
-        \normalsize
+        {\Huge\bf \eprint{title}}
+
+        \vspace*{1.0cm}
+
         by \\
 
         \vspace*{1.0cm}
 
-        \Large
-        Pat Neugraad \\
+        {\Large \eprint{author}} \\
 
         \vspace*{3.0cm}
 
-        \normalsize
         A thesis \\
         presented to the University of Waterloo \\ 
         in fulfillment of the \\
         thesis requirement for the degree of \\
-        Doctor of Philosophy \\
+        \eprint{degree} \\
         in \\
-        Zoology \\
+        \eprint{program} \\
 
         \vspace*{2.0cm}
@@ -45 +49 @@
         \vspace*{1.0cm}
 
-        \copyright\ Pat Neugraad 2017 \\
+        \copyright{} \eprint{author} 2017 \\
         \end{center}
 \end{titlepage}

doc/theses/andrew_beach_MMath/uw-ethesis.cls

@@ -19 +19 @@
 %
 % Exported Names:
+%   \ethesissetup{<key-value-pairs>}
+%     Preforms set-up (or a reconfiguration) of the document class. See the
+%     Set-Up Keys section for the keys that may be passed in. Use commas to
+%     seperate key-value-pairs.
+%
 %   \ifformat{<format>}{<true>}{<false>}
 %     If the document's format is <format> than expands to <true> otherwise
@@ -27 +32 @@
 %     initial setup depends on the document format but they can be overriden
 %     with options in <setup> (set hyperref's \hypersetup for details).
+%
+%   \eprint{<key>}
+%     Expands to a human readable value tracked by the ethesis class. This
+%     can be used to retreave and format values set during set up.
+%
+% Set-Up Keys:
+%   author=<text>
+%   title=<text>
+%   program=<text>
+%   subject=<text>
+%   keywords=<text>
+%   degree=masters|phd
+%   faculty=ahs|arts|eng|env|math|sci
 \NeedsTeXFormat{LaTeX2e}
-\ProvidesClass{uw-ethesis}[2020/03/24 v0.1 UW-eThesis Template Document Class]
+\ProvidesClass{uw-ethesis}[2020/10/25 v0.2 UW-eThesis Template Document Class]
 
 \RequirePackage{etoolbox}
+\RequirePackage{xkeyval}
 
 % Requested Format:
-\newrobustcmd*{\ethesis@format}{digital}
-\DeclareOption{print}{\renewrobustcmd*{\ethesis@format}{print}}
-\DeclareOption{digital}{\renewrobustcmd*{\ethesis@format}{digital}}
+\newrobustcmd*{\ethesis@@format}{digital}
+\DeclareOption{print}{\renewrobustcmd*{\ethesis@@format}{print}}
+\DeclareOption{digital}{\renewrobustcmd*{\ethesis@@format}{digital}}
 
 \ProcessOptions\relax
@@ -81 +100 @@
 % a recto page. This will often require an empty verso (left-hand side) page
 % that should not have the page number printed on it.
-\let\origdoublepage\cleardoublepage
+\let\ethesis@origdoublepage\cleardoublepage
 \newcommand{\clearemptydoublepage}{%
-  \clearpage{\pagestyle{empty}\origdoublepage}}
+  \clearpage{\pagestyle{empty}\ethesis@origdoublepage}}
 \let\cleardoublepage\clearemptydoublepage
 
@@ -89 +108 @@
 \renewcommand*{\bibname}{References}
 
-% Configurations
-\def\setThesisTitle#1{\newrobustcmd*{\ethesis@title}{#1}}
-\def\setThesisAuthor#1{\newrobustcmd*{\ethesis@author}{#1}}
-\def\setThesisSubject#1{\newrobustcmd*{\ethesis@subject}{#1}}
-\def\setThesisKeywords#1{\newrobustcmd*{\ethesis@keywords}{#1}}
+\newrobustcmd*\ethesissetup[1]{\setkeys{ethesis}{#1}}
+
+\define@cmdkeys{ethesis}[ethesis@@]{%
+  author,title,program,subject,keywords}
+
+\define@choicekey{ethesis}{degree}{masters,phd}{\def\ethesis@@degree{#1}}
+\define@choicekey{ethesis}{faculty}{ahs,arts,eng,env,math,sci}%
+  {\def\ethesis@@faculty{#1}}
+
+\newrobustcmd*\eprint[1]{
+  \ifcsdef{ethesis@long#1}{\csuse{ethesis@long#1}}{%
+    \ifcsdef{ethesis@@#1}{\csuse{ethesis@@#1}}{%
+      % ERROR: (Check for a way to emit an actual error.)
+      [UW-eThesis doesn't know how to print: #1 ]
+    }
+  }
+}
+
+\newrobustcmd*\ethesis@longdegree{%
+  \ifdefstring{\ethesis@@degree}{phd}{Doctor of Philosophy}{Masters}}
 
 % Includes the hyperref package loading a number of defaults.
@@ -106 +140 @@
     pdfstartview={FitH},    % Fits the width of the page to the window.
   }
-  \ifdef{\ethesis@title}{\hypersetup{pdftitle={\ethesis@title}}}{}
-  \ifdef{\ethesis@author}{\hypersetup{pdfauthor={\ethesis@author}}}{}
-  \ifdef{\ethesis@subject}{\hypersetup{pdfsubject={\ethesis@subject}}}{}
-  \ifdef{\ethesis@keywords}{\hypersetup{pdfkeywords={\ethesis@keywords}}}{}
+  \ifdef{\ethesis@@title}{\hypersetup{pdftitle={\ethesis@@title}}}{}
+  \ifdef{\ethesis@@author}{\hypersetup{pdfauthor={\ethesis@@author}}}{}
+  \ifdef{\ethesis@@subject}{\hypersetup{pdfsubject={\ethesis@@subject}}}{}
+  \ifdef{\ethesis@@keywords}{\hypersetup{pdfkeywords={\ethesis@@keywords}}}{}
   \ifformat{print}{
     \hypersetup{

libcfa/prelude/builtins.c

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Fri Jul 21 16:21:03 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct  9 18:26:19 2020
-// Update Count     : 110
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct 27 14:42:00 2020
+// Update Count     : 111
 //
+
+#define __cforall_builtins__
 
 // type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions

libcfa/src/concurrency/coroutine.cfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 26 22:06:09 2020
-// Update Count     : 21
+// Last Modified On : Fri Oct 23 23:05:24 2020
+// Update Count     : 22
 //
 
@@ -24 +24 @@
 #include <unistd.h>
 #include <sys/mman.h>                                                                   // mprotect
-extern "C" {
-// use this define to make unwind.h play nice, definitely a hack
-#define HIDE_EXPORTS
 #include <unwind.h>
-#undef HIDE_EXPORTS
-}
 
 #include "kernel_private.hfa"
+#include "exception.hfa"
 
 #define __CFA_INVOKE_PRIVATE__
@@ -49 +45 @@
 FORALL_DATA_INSTANCE(CoroutineCancelled, (dtype coroutine_t), (coroutine_t))
 
-struct __cfaehm_node {
-        struct _Unwind_Exception unwind_exception;
-        struct __cfaehm_node * next;
-        int handler_index;
-};
-
 forall(dtype T)
 void mark_exception(CoroutineCancelled(T) *) {}
@@ -60 +50 @@
 forall(dtype T)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
+        dst->virtual_table = src->virtual_table;
         dst->the_coroutine = src->the_coroutine;
         dst->the_exception = src->the_exception;
@@ -74 +65 @@
         verify( desc->cancellation );
         desc->state = Cancelled;
-        exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
+        exception_t * except = __cfaehm_cancellation_exception( desc->cancellation );
 
         // TODO: Remove explitate vtable set once trac#186 is fixed.
@@ -217 +208 @@
                 size = libFloor(create_size - stack_data_size - diff, libAlign());
         } // if
-        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
+        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize );
 
         this->storage = (__stack_t *)((intptr_t)storage + size);

libcfa/src/concurrency/exception.cfa

@@ -10 +10 @@
 // Created On       : Mon Aug 17 10:41:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Aug 25 14:41:00 2020
-// Update Count     : 0
+// Last Modified On : Wed Oct 28 14:34:00 2020
+// Update Count     : 1
 //
 
-extern "C" {
-// use this define to make unwind.h play nice, definitely a hack
-#define HIDE_EXPORTS
-#include <unwind.h>
-#undef HIDE_EXPORTS
-}
+#define __cforall_thread__
 
-#include "invoke.h"
 #include "exception.hfa"
+
 #include "coroutine.hfa"
 
 extern struct $thread * mainThread;
+extern "C" {
+extern void __cfactx_thrd_leave();
+}
 
 // Common pattern for all the stop functions, wait until the end then act.
@@ -52 +50 @@
 
 STOP_AT_END_FUNCTION(thread_cancelstop,
-        // TODO: Instead pass information to the joiner.
-        abort();
+        __cfactx_thrd_leave();
+        __cabi_abort( "Resumed cancelled thread" );
 )
 
@@ -85 +83 @@
                 stop_param = (void *)0x22;
         } else {
+                this_thread->self_cor.cancellation = unwind_exception;
+
                 stop_func = thread_cancelstop;
                 stop_param = this_thread;

libcfa/src/concurrency/exception.hfa

@@ -16 +16 @@
 #pragma once
 
+// This is an internal bridge between the two modes and must be C compatable.
+
+#include <unwind.h>
 #include "bits/defs.hfa"
 #include "invoke.h"
+#include "exception.h"
 
 #ifdef __cforall
 extern "C" {
-
-#define HIDE_EXPORTS
 #endif
-#include "unwind.h"
 
 struct exception_context_t * this_exception_context(void) OPTIONAL_THREAD;
@@ -32 +33 @@
 
 #ifdef __cforall
-#undef HIDE_EXPORTS
 }
 #endif

libcfa/src/concurrency/invoke.h

@@ -157 +157 @@
 
                 // current execution status for coroutine
+                // Possible values are:
+                //    - TICKET_BLOCKED (-1) thread is blocked
+                //    - TICKET_RUNNING ( 0) thread is running
+                //    - TICKET_UNBLOCK ( 1) thread should ignore next block
                 volatile int ticket;
                 enum __Coroutine_State state:8;

libcfa/src/concurrency/io/setup.cfa

@@ -250 +250 @@
                                         // Fixup the thread state
                                         thrd.state = Blocked;
-                                        thrd.ticket = 0;
+                                        thrd.ticket = TICKET_BLOCKED;
                                         thrd.preempted = __NO_PREEMPTION;
 

libcfa/src/concurrency/kernel.cfa

@@ -252 +252 @@
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
                 /* paranoid */ verify( thrd_dst->context.SP );
+                /* paranoid */ verify( thrd_dst->state != Halted );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
@@ -287 +288 @@
                 if(unlikely(thrd_dst->state == Halted)) {
                         // The thread has halted, it should never be scheduled/run again
-                        // We may need to wake someone up here since
-                        unpark( this->destroyer );
-                        this->destroyer = 0p;
+                        // finish the thread
+                        __thread_finish( thrd_dst );
                         break RUNNING;
                 }
@@ -299 +299 @@
                 int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
                 switch(old_ticket) {
-                        case 1:
+                        case TICKET_RUNNING:
                                 // This is case 1, the regular case, nothing more is needed
                                 break RUNNING;
-                        case 2:
+                        case TICKET_UNBLOCK:
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
                                 // In this case, just run it again.
@@ -410 +410 @@
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
         switch(old_ticket) {
-                case 1:
+                case TICKET_RUNNING:
                         // Wake won the race, the thread will reschedule/rerun itself
                         break;
-                case 0:
+                case TICKET_BLOCKED:
                         /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
                         /* paranoid */ verify( thrd->state == Blocked );
@@ -422 +422 @@
                 default:
                         // This makes no sense, something is wrong abort
-                        abort();
+                        abort("Thread %p (%s) has mismatch park/unpark\n", thrd, thrd->self_cor.name);
         }
 }
@@ -448 +448 @@
 }
 
-// KERNEL ONLY
-void __leave_thread() {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        abort();
+extern "C" {
+        // Leave the thread monitor
+        // last routine called by a thread.
+        // Should never return
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
+
+                // Lock the monitor now
+                lock( this->lock __cfaabi_dbg_ctx2 );
+
+                disable_interrupts();
+
+                thrd->state = Halted;
+
+                if( thrd != this->owner || this->recursion != 1) { abort( "Thread internal monitor has unbalanced recursion" ); }
+
+                // Leave the thread
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                returnToKernel();
+                abort();
+
+                // Control flow should never reach here!
+        }
 }
 

libcfa/src/concurrency/kernel.hfa

@@ -79 +79 @@
         // Handle to pthreads
         pthread_t kernel_thread;
-
-        // RunThread data
-        // Action to do after a thread is ran
-        $thread * destroyer;
 
         // Preemption data

libcfa/src/concurrency/kernel/startup.cfa

@@ -441 +441 @@
 
 static void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
-        ticket = 1;
+        ticket = TICKET_RUNNING;
         state = Start;
         self_cor{ info };
@@ -474 +474 @@
         this.cltr = &_cltr;
         full_proc = true;
-        destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;

libcfa/src/concurrency/kernel_private.hfa

@@ -39 +39 @@
 ;
 
-//Block current thread and release/wake-up the following resources
-void __leave_thread() __attribute__((noreturn));
+//release/wake-up the following resources
+void __thread_finish( $thread * thrd );
 
 //-----------------------------------------------------------------------------
@@ -65 +65 @@
 // KERNEL ONLY unpark with out disabling interrupts
 void __unpark( struct __processor_id_t *, $thread * thrd );
+
+#define TICKET_BLOCKED (-1) // thread is blocked
+#define TICKET_RUNNING ( 0) // thread is running
+#define TICKET_UNBLOCK ( 1) // thread should ignore next block
 
 static inline bool __post(single_sem & this, struct __processor_id_t * id) {

libcfa/src/concurrency/monitor.cfa

@@ -281 +281 @@
 }
 
-extern "C" {
-        // Leave the thread monitor
-        // last routine called by a thread.
-        // Should never return
-        void __cfactx_thrd_leave() {
-                $thread * thrd = TL_GET( this_thread );
-                $monitor * this = &thrd->self_mon;
-
-                // Lock the monitor now
-                lock( this->lock __cfaabi_dbg_ctx2 );
-
-                disable_interrupts();
-
-                thrd->state = Halted;
-
-                /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
-
-                // Leaving a recursion level, decrement the counter
-                this->recursion -= 1;
-
-                // If we haven't left the last level of recursion
-                // it must mean there is an error
-                if( this->recursion != 0) { abort( "Thread internal monitor has unbalanced recursion" ); }
-
-                // Fetch the next thread, can be null
-                $thread * new_owner = next_thread( this );
-
-                // Release the monitor lock
-                unlock( this->lock );
-
-                // Unpark the next owner if needed
-                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
-                /* paranoid */ verify( thrd->state == Halted );
-
-                kernelTLS.this_processor->destroyer = new_owner;
-
-                // Leave the thread
-                __leave_thread();
-
-                // Control flow should never reach here!
-        }
-}
-
-// Join a thread
-forall( dtype T | is_thread(T) )
-T & join( T & this ) {
-        $monitor *    m = get_monitor(this);
-        void (*dtor)(T& mutex this) = ^?{};
-        monitor_dtor_guard_t __guard = { &m, (fptr_t)dtor, true };
-        {
-                return this;
-        }
+void __thread_finish( $thread * thrd ) {
+        $monitor * this = &thrd->self_mon;
+
+        // Lock the monitor now
+        /* paranoid */ verify( this->lock.lock );
+        /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( thrd->state == Halted );
+        /* paranoid */ verify( this->recursion == 1 );
+
+        // Leaving a recursion level, decrement the counter
+        this->recursion -= 1;
+        this->owner = 0p;
+
+        // Fetch the next thread, can be null
+        $thread * new_owner = next_thread( this );
+
+        // Release the monitor lock
+        unlock( this->lock );
+
+        // Unpark the next owner if needed
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( thrd->state == Halted );
+        unpark( new_owner );
 }
 

libcfa/src/concurrency/thread.cfa

@@ -19 +19 @@
 
 #include "kernel_private.hfa"
+#include "exception.hfa"
 
 #define __CFA_INVOKE_PRIVATE__
@@ -28 +29 @@
         context{ 0p, 0p };
         self_cor{ name, storage, storageSize };
-        ticket = 1;
+        ticket = TICKET_RUNNING;
         state = Start;
         preempted = __NO_PREEMPTION;
@@ -56 +57 @@
         unregister(curr_cluster, this);
         ^self_cor{};
+}
+
+FORALL_DATA_INSTANCE(ThreadCancelled, (dtype thread_t), (thread_t))
+
+forall(dtype T)
+void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src) {
+        dst->virtual_table = src->virtual_table;
+        dst->the_thread = src->the_thread;
+        dst->the_exception = src->the_exception;
+}
+
+forall(dtype T)
+const char * msg(ThreadCancelled(T) *) {
+        return "ThreadCancelled";
+}
+
+forall(dtype T)
+static void default_thread_cancel_handler(ThreadCancelled(T) & ) {
+        abort( "Unhandled thread cancellation.\n" );
+}
+
+forall(dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)))
+void ?{}( thread_dtor_guard_t & this,
+                T & thrd, void(*defaultResumptionHandler)(ThreadCancelled(T) &)) {
+        $monitor * m = get_monitor(thrd);
+        void (*dtor)(T& mutex this) = ^?{};
+        bool join = defaultResumptionHandler != (void(*)(ThreadCancelled(T)&))0;
+        (this.mg){&m, (void(*)())dtor, join};
+
+        // After the guard set-up and any wait, check for cancellation.
+        $thread * desc = get_thread(thrd);
+        struct _Unwind_Exception * cancellation = desc->self_cor.cancellation;
+        if ( likely( 0p == cancellation ) ) {
+                return;
+        } else if ( Cancelled == desc->state ) {
+                return;
+        }
+        desc->state = Cancelled;
+        if (!join) {
+                defaultResumptionHandler = default_thread_cancel_handler;
+        }
+
+        ThreadCancelled(T) except;
+        // TODO: Remove explitate vtable set once trac#186 is fixed.
+        except.virtual_table = &get_exception_vtable(&except);
+        except.the_thread = &thrd;
+        except.the_exception = __cfaehm_cancellation_exception( cancellation );
+        throwResume except;
+
+        except.the_exception->virtual_table->free( except.the_exception );
+        free( cancellation );
+        desc->self_cor.cancellation = 0p;
+}
+
+void ^?{}( thread_dtor_guard_t & this ) {
+        ^(this.mg){};
 }
 
@@ -93 +150 @@
 }
 
+//-----------------------------------------------------------------------------
+forall(dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)))
+T & join( T & this ) {
+        thread_dtor_guard_t guard = { this, defaultResumptionHandler };
+        return this;
+}
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

@@ -22 +22 @@
 #include "kernel.hfa"
 #include "monitor.hfa"
+#include "exception.hfa"
 
 //-----------------------------------------------------------------------------
 // thread trait
 trait is_thread(dtype T) {
-      void ^?{}(T& mutex this);
-      void main(T& this);
-      $thread* get_thread(T& this);
+        void ^?{}(T& mutex this);
+        void main(T& this);
+        $thread* get_thread(T& this);
 };
+
+FORALL_DATA_EXCEPTION(ThreadCancelled, (dtype thread_t), (thread_t)) (
+        thread_t * the_thread;
+        exception_t * the_exception;
+);
+
+forall(dtype T)
+void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src);
+
+forall(dtype T)
+const char * msg(ThreadCancelled(T) *);
 
 // define that satisfies the trait without using the thread keyword
@@ -65 +77 @@
 static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
 static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+
+struct thread_dtor_guard_t {
+        monitor_dtor_guard_t mg;
+};
+
+forall( dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) )
+void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
+void ^?{}( thread_dtor_guard_t & this );
 
 //-----------------------------------------------------------------------------
@@ -108 +128 @@
 //----------
 // join
-forall( dtype T | is_thread(T) )
+forall( dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) )
 T & join( T & this );
 

libcfa/src/exception.c

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 29 15:52:22 2020
-// Update Count     : 34
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct 27 16:27:00 2020
+// Update Count     : 35
 //
 
@@ -17 +17 @@
 #include <stddef.h> // for size_t
 
+#include <unwind.h> // for struct _Unwind_Exception {...};
+
 #include "exception.h"
 
 #include <stdlib.h>
 #include <stdio.h>
-#include <unwind.h>
 #include <bits/debug.hfa>
 #include "concurrency/invoke.h"
@@ -113 +114 @@
 
 // MEMORY MANAGEMENT =========================================================
-
-struct __cfaehm_node {
-        struct _Unwind_Exception unwind_exception;
-        struct __cfaehm_node * next;
-        int handler_index;
-};
 
 #define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))

libcfa/src/exception.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// exception.h -- Builtins for exception handling.
+// exception.h -- Internal exception handling definitions.
 //
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue May 19 14:17:00 2020
-// Update Count     : 10
+// Last Modified On : Tue Oct 27 14:45:00 2020
+// Update Count     : 11
 //
 
 #pragma once
 
+// This could be considered several headers. All are internal to the exception
+// system but needed to depending on whether they are C/Cforall code and
+// whether or not they are part of the builtins.
 
 #ifdef __cforall
 extern "C" {
 #endif
+
+// Included in C code or the built-ins.
+#if !defined(__cforall) || defined(__cforall_builtins__)
 
 struct __cfaehm_base_exception_t;
@@ -47 +53 @@
 // Function catches termination exceptions.
 void __cfaehm_try_terminate(
-    void (*try_block)(),
-    void (*catch_block)(int index, exception_t * except),
-    int (*match_block)(exception_t * except));
+        void (*try_block)(),
+        void (*catch_block)(int index, exception_t * except),
+        int (*match_block)(exception_t * except));
 
 // Clean-up the exception in catch blocks.
@@ -56 +62 @@
 // Data structure creates a list of resume handlers.
 struct __cfaehm_try_resume_node {
-    struct __cfaehm_try_resume_node * next;
-    _Bool (*handler)(exception_t * except);
+        struct __cfaehm_try_resume_node * next;
+        _Bool (*handler)(exception_t * except);
 };
 
 // These act as constructor and destructor for the resume node.
 void __cfaehm_try_resume_setup(
-    struct __cfaehm_try_resume_node * node,
-    _Bool (*handler)(exception_t * except));
+        struct __cfaehm_try_resume_node * node,
+        _Bool (*handler)(exception_t * except));
 void __cfaehm_try_resume_cleanup(
-    struct __cfaehm_try_resume_node * node);
+        struct __cfaehm_try_resume_node * node);
 
 // Check for a standard way to call fake deconstructors.
 struct __cfaehm_cleanup_hook {};
 
+#endif
+
+// Included in C code and the library.
+#if !defined(__cforall) || !defined(__cforall_builtins__)
+struct __cfaehm_node {
+        struct _Unwind_Exception unwind_exception;
+        struct __cfaehm_node * next;
+        int handler_index;
+};
+
+static inline exception_t * __cfaehm_cancellation_exception(
+                struct _Unwind_Exception * unwind_exception ) {
+        return (exception_t *)(1 + (struct __cfaehm_node *)unwind_exception);
+}
+#endif
+
 #ifdef __cforall
 }
+
+// Built-ins not visible in C.
+#if defined(__cforall_builtins__)
 
 // Not all the built-ins can be expressed in C. These can't be
@@ -124 +149 @@
 
 #endif
+
+#endif

src/AST/Convert.cpp

@@ -47 +47 @@
 
 //================================================================================================
-namespace {
+namespace ast {
 
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
+// xxx - since convert back pass works, this concern seems to be unnecessary.
+
+// these need to be accessed in new FixInit now
 ast::Type * sizeType = nullptr;
 ast::FunctionDecl * dereferenceOperator = nullptr;
@@ -63 +66 @@
         using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
         Cache cache;
+
+        // Statements can no longer be shared.
+        // however, since StmtExprResult is now implemented, need to still maintain
+        // readonly references.
+        Cache readonlyCache;
 
         template<typename T>
@@ -154 +162 @@
         }
 
-        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
-                auto&& type = get<Type>().accept1( node->type );
-                auto&& init = get<Initializer>().accept1( node->init );
-                auto&& attr = get<Attribute>().acceptL( node->attributes );
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {        
                 if ( inCache( node ) ) {
                         return nullptr;
                 }
+                auto bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto type = get<Type>().accept1( node->type );
+                auto attr = get<Attribute>().acceptL( node->attributes );
+
                 auto decl = new ObjectDecl(
                         node->name,
@@ -168 +176 @@
                         bfwd,
                         type->clone(),
-                        init,
+                        nullptr, // prevent infinite loop
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
-                return declWithTypePostamble( decl, node );
+
+                // handles the case where node->init references itself
+                // xxx - does it really happen?
+                declWithTypePostamble(decl, node);
+                auto init = get<Initializer>().accept1( node->init );
+                decl->init = init;
+                
+                this->node = decl;
+                return nullptr;
         }
 
@@ -205 +221 @@
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
-                if ( dereferenceOperator == node ) {
+                if ( ast::dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
                 }
-                if ( dtorStructDestroy == node ) {
+                if ( ast::dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
                 }
@@ -267 +283 @@
                 );
 
-                if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -320 +336 @@
 
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
-                cache.emplace( node, stmt );
+                // force statements in old tree to be unique.
+                // cache.emplace( node, stmt );
+                readonlyCache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -337 +355 @@
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new ExprStmt( nullptr );
-                cache.emplace( node, stmt );
                 stmt->expr = get<Expression>().accept1( node->expr );
                 return stmtPostamble( stmt, node );
@@ -1011 +1028 @@
                 auto stmts = node->stmts;
                 // disable sharing between multiple StmtExprs explicitly.
-                if (inCache(stmts)) {
-                        stmts = ast::deepCopy(stmts.get());
-                }
+                // this should no longer be true.
+
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
@@ -1020 +1036 @@
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
 
                 auto expr = visitBaseExpr( node, rslt );
@@ -1036 +1056 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
         }
@@ -1126 +1146 @@
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
-                if ( sizeType == node ) {
+                if ( ast::sizeType == node ) {
                         Validate::SizeType = type;
                 }
@@ -1529 +1549 @@
 
                 // function type is now derived from parameter decls instead of storing them
+
+                /*
                 auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
                 ftype->params.reserve(paramVars.size());
@@ -1540 +1562 @@
                 }
                 ftype->forall = std::move(forall);
-                visitType(old->type, ftype);
+                */
+
+                // can function type have attributes? seems not to be the case.
+                // visitType(old->type, ftype);
 
                 auto decl = new ast::FunctionDecl{
@@ -1546 +1571 @@
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
+                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1552 +1578 @@
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->get_funcSpec().val }
+                        { old->get_funcSpec().val },
+                        old->type->isVarArgs
                 };
 
-                decl->type = ftype;
+                // decl->type = ftype;
                 cache.emplace( old, decl );
 
@@ -1570 +1597 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
                 }
         }
@@ -1599 +1626 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        dtorStruct = decl;
+                        ast::dtorStruct = decl;
                 }
         }
@@ -2531 +2558 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        sizeType = type;
+                        ast::sizeType = type;
                 }
                 visitType( old, type );

src/AST/Decl.cpp

@@ -48 +48 @@
 
 // --- FunctionDecl
+
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+                std::vector<ptr<TypeDecl>>&& forall,
+                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)
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+          stmts( stmts ) {
+                  FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+                  for (auto & param : this->params) {
+                          ftype->params.emplace_back(param->get_type());
+                  }
+                  for (auto & ret : this->returns) {
+                          ftype->returns.emplace_back(ret->get_type());
+                  }
+                  ftype->forall = std::move(forall);
+                  this->type = ftype;
+          }
+
 
 const Type * FunctionDecl::get_type() const { return type.get(); }

src/AST/Decl.hpp

@@ -131 +131 @@
         std::vector< ptr<Expr> > withExprs;
 
-        FunctionDecl( const CodeLocation & loc, const std::string & name, 
+        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-          stmts( stmts ) {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        //  stmts( stmts ) {}
 
         const Type * get_type() const override;

src/AST/DeclReplacer.cpp

@@ -38 +38 @@
                         const ast::TypeInstType * previsit( const ast::TypeInstType * );
                 };
+
+                struct VarExprReplacer {
+                private:
+                        const ExprMap & exprMap;
+                        
+                public:
+                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+
+                        const Expr * postvisit (const VariableExpr *);
+                };
         }
 
@@ -54 +64 @@
                 DeclMap declMap;
                 return replace( node, declMap, typeMap, debug );
+        }
+
+        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
+                Pass<VarExprReplacer> replacer = {exprMap};
+                return node->accept( replacer );
         }
 
@@ -88 +103 @@
                         return ninst;
                 }
+
+                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                        if (!exprMap.count(expr->var)) return expr;
+
+                        return exprMap.at(expr->var);
+                }
+
         }
 }

src/AST/DeclReplacer.hpp

@@ -23 +23 @@
         class DeclWithType;
         class TypeDecl;
+        class Expr;
 
         namespace DeclReplacer {
                 using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
                 using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
+                using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
 
                 const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
                 const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
                 const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+                const Node * replace( const Node * node, const ExprMap & exprMap);
         }
 }

src/AST/Expr.cpp

@@ -67 +67 @@
 // --- UntypedExpr
 
-UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, Expr * arg ) {
+UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
@@ -92 +92 @@
 }
 
-UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
+UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 
@@ -102 +102 @@
         }
         return ret;
+}
+
+// --- VariableExpr
+
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
+VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
+: Expr( loc ), var( v ) {
+        assert( var );
+        assert( var->get_type() );
+        result = shallowCopy( var->get_type() );
+}
+
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
+}
+
+VariableExpr * VariableExpr::functionPointer(
+                const CodeLocation & loc, const FunctionDecl * decl ) {
+        // wrap usually-determined result type in a pointer
+        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
+        funcExpr->result = new PointerType{ funcExpr->result };
+        return funcExpr;
 }
 
@@ -238 +263 @@
 }
 
-// --- VariableExpr
-
-VariableExpr::VariableExpr( const CodeLocation & loc )
-: Expr( loc ), var( nullptr ) {}
-
-VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
-: Expr( loc ), var( v ) {
-        assert( var );
-        assert( var->get_type() );
-        result = shallowCopy( var->get_type() );
-}
-
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
-}
-
-VariableExpr * VariableExpr::functionPointer(
-                const CodeLocation & loc, const FunctionDecl * decl ) {
-        // wrap usually-determined result type in a pointer
-        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
-        funcExpr->result = new PointerType{ funcExpr->result };
-        return funcExpr;
-}
-
 // --- ConstantExpr
 

src/AST/Expr.hpp

@@ -226 +226 @@
 
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -247 +247 @@
 private:
         NameExpr * clone() const override { return new NameExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+
+        VariableExpr( const CodeLocation & loc );
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
+
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
         MUTATE_FRIEND
 };
@@ -392 +411 @@
 };
 
-/// A reference to a named variable.
-class VariableExpr final : public Expr {
-public:
-        readonly<DeclWithType> var;
-
-        VariableExpr( const CodeLocation & loc );
-        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-
-        bool get_lvalue() const final;
-
-        /// generates a function pointer for a given function
-        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
-        MUTATE_FRIEND
-};
-
 /// A compile-time constant.
 /// Mostly carries C-source text from parse to code-gen, without interpretation.  E.g. strings keep their outer quotes and never have backslashes interpreted.
@@ -422 +422 @@
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ) {}
+        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -617 +617 @@
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
-        : Expr( loc, call->result ) { assert( call ); }
+        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -742 +742 @@
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
+        readonly<ExprStmt> resultExpr;
+
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );
 

src/AST/Fwd.hpp

@@ -137 +137 @@
 typedef unsigned int UniqueId;
 
+extern Type * sizeType;
+extern FunctionDecl * dereferenceOperator;
+extern StructDecl   * dtorStruct;
+extern FunctionDecl * dtorStructDestroy;
+
 }

src/AST/Node.hpp

@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
+        bool isManaged() const {return strong_count > 0; }
 
 private:

src/AST/Pass.hpp

@@ -228 +228 @@
         template<typename core_type>
         friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor );
+
+        bool isInFunction() const {
+                return inFunction;
+        }
+
 private:
 
@@ -235 +240 @@
         const ast::Stmt * call_accept( const ast::Stmt * );
         const ast::Expr * call_accept( const ast::Expr * );
+
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+
+        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
 
         template< typename node_t >
@@ -257 +266 @@
         template<typename node_t, typename parent_t, typename child_t>
         void maybe_accept(const node_t * &, child_t parent_t::* child);
+
+        template<typename node_t, typename parent_t, typename child_t>
+        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
 
 private:
@@ -284 +296 @@
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 };
 
@@ -371 +384 @@
 struct WithVisitorRef {
         Pass<core_t> * const visitor = nullptr;
+
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };
 

src/AST/Pass.impl.hpp

@@ -167 +167 @@
                 __pedantic_pass_assert( stmt );
 
+                return stmt->accept( *this );
+        }
+
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+                __pedantic_pass_assert( __visit_children() );
+                __pedantic_pass_assert( stmt );
+
                 // add a few useful symbols to the scope
                 using __pass::empty;
@@ -324 +332 @@
 
                 auto new_val = call_accept( old_val );
+
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
+
+                if( __pass::differs(old_val, new_val) ) {
+                        auto new_parent = __pass::mutate<core_t>(parent);
+                        new_parent->*child = new_val;
+                        parent = new_parent;
+                }
+        }
+
+        template< typename core_t >
+        template<typename node_t, typename parent_t, typename child_t>
+        void ast::Pass< core_t >::maybe_accept_as_compound(
+                const node_t * & parent,
+                child_t parent_t::*child
+        ) {
+                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*child)) return;
+                const auto & old_val = __pass::get(parent->*child, 0);
+
+                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
+
+                auto new_val = call_accept_as_compound( old_val );
 
                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
@@ -470 +502 @@
                                 // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
-                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                                // a new scope if inFunction is true
+                                // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
                                 inFunction = true;
+                                // The function body needs to have the same scope as parameters.
+                                // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                                atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
@@ -640 +675 @@
         VISIT_START( node );
         VISIT({
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
-                }, [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
+                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
+                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
+                        if ( enterScope ) __pass::symtab::enter(core, 0);
+                }, [this, leaveScope = !this->atFunctionTop]() {
+                        if ( leaveScope ) __pass::symtab::leave(core, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -703 +738 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept( node, &IfStmt::thenPart );
-                maybe_accept( node, &IfStmt::elsePart );
+                maybe_accept_as_compound( node, &IfStmt::thenPart );
+                maybe_accept_as_compound( node, &IfStmt::elsePart );
         })
 
@@ -721 +756 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 
@@ -736 +771 @@
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
+                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
                 maybe_accept( node, &ForStmt::inc   );
-                maybe_accept( node, &ForStmt::body  );
+                maybe_accept_as_compound( node, &ForStmt::body  );
         })
 
@@ -834 +870 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })
 

src/AST/SymbolTable.cpp

@@ -335 +335 @@
 }
 
-/*
-void SymbolTable::addFunctionType( const FunctionType * ftype ) {
-        addTypes( ftype->forall );
-        addIds( ftype->returns );
-        addIds( ftype->params );
-}
-*/
+
+void SymbolTable::addFunction( const FunctionDecl * func ) {
+        addTypes( func->type->forall );
+        addIds( func->returns );
+        addIds( func->params );
+}
+
 
 void SymbolTable::lazyInitScope() {

src/AST/SymbolTable.hpp

@@ -145 +145 @@
 
         /// convenience function for adding all of the declarations in a function type to the indexer
-        // void addFunctionType( const FunctionType * ftype );
+        void addFunction( const FunctionDecl * );
 
 private:

src/AST/Type.cpp

@@ -157 +157 @@
 
 template<typename decl_t>
+SueInstType<decl_t>::SueInstType(
+        const base_type * b, std::vector<ptr<Expr>> && params,
+        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
+: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
+
+template<typename decl_t>
 bool SueInstType<decl_t>::isComplete() const {
         return base ? base->body : false;

src/AST/Type.hpp

@@ -302 +302 @@
 class FunctionType final : public ParameterizedType {
 public:
-//      std::vector<ptr<DeclWithType>> returns;
-//      std::vector<ptr<DeclWithType>> params;
-
         std::vector<ptr<Type>> returns;
         std::vector<ptr<Type>> params;
@@ -345 +342 @@
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
 
+        BaseInstType(
+                const std::string& n, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : ParameterizedType(q, std::move(as)), params(std::move(params)), name(n) {}
+
         BaseInstType( const BaseInstType & o );
 
@@ -369 +371 @@
 
         SueInstType(
-                const decl_t * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+                const base_type * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+
+        SueInstType(
+                const base_type * b, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;

src/AST/porting.md

@@ -30 +30 @@
   * Base nodes now override `const Node * accept( Visitor & v ) const = 0` with, e.g. `const Stmt * accept( Visitor & v ) const override = 0`
 * `PassVisitor` is replaced with `ast::Pass`
+  * Most one shot uses can use `ast::Pass::run` and `ast::Pass::read`.
+
+`WithConstTypeSubstitution`
+* `env` => `typeSubs`
 
 ## Structural Changes ##
@@ -146 +150 @@
   * allows `newObject` as just default settings
 
+`FunctionDecl`
+* `params` and `returns` added.
+  * Contain the declarations of the parameters and return variables.
+  * Types should match (even be shared with) the fields of `type`.
+
 `NamedTypeDecl`
 * `parameters` => `params`
@@ -154 +163 @@
 `AggregateDecl`
 * `parameters` => `params`
+
+`StructDecl`
+* `makeInst` replaced by better constructor on `StructInstType`.
 
 `Expr`
@@ -245 +257 @@
 * **TODO** move `kind`, `typeNames` into code generator
 
-`ReferenceToType`
+`ReferenceToType` => `BaseInstType`
 * deleted `get_baseParameters()` from children
   * replace with `aggr() ? aggr()->params : nullptr`
@@ -261 +273 @@
 * `returnVals` => `returns`
 * `parameters` => `params`
+  * Both now just point at types.
 * `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
+
+`SueInstType`
+* Template class, with specializations and using to implement some other types:
+  * `StructInstType`, `UnionInstType` & `EnumInstType`
 
 `TypeInstType`

src/Common/PassVisitor.h

@@ -354 +354 @@
         virtual TypeSubstitution * mutate( TypeSubstitution * sub ) final;
 
+        bool isInFunction() const {
+                return inFunction;
+        }
+
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
@@ -526 +531 @@
 public:
         PassVisitor<pass_type> * const visitor = nullptr;
+
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };
 

src/Common/PassVisitor.impl.h

@@ -532 +532 @@
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
-                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
@@ -567 +570 @@
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
-                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
@@ -601 +607 @@
                         indexerAddId( &func );
                         maybeMutate_impl( node->type, *this );
-                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeMutate_impl( node->statements, *this );
                         maybeMutate_impl( node->attributes, *this );
@@ -1007 +1016 @@
         VISIT_START( node );
         {
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                ValueGuard< bool > oldInFunction( inFunction );
-                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
-                inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
         }
@@ -1021 +1030 @@
         VISIT_START( node );
         {
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                ValueGuard< bool > oldInFunction( inFunction );
-                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
-                inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
         }
@@ -1035 +1044 @@
         MUTATE_START( node );
         {
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                ValueGuard< bool > oldInFunction( inFunction );
-                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
-                inFunction = false;
+                atFunctionTop = false;
                 mutateStatementList( node->kids );
         }

src/Common/utility.h

@@ -360 +360 @@
         reverse_iterate_t( T & ref ) : ref(ref) {}
 
-        typedef typename T::reverse_iterator iterator;
-        iterator begin() { return ref.rbegin(); }
-        iterator end() { return ref.rend(); }
+        // this does NOT work on const T!!!
+        // typedef typename T::reverse_iterator iterator;
+        auto begin() { return ref.rbegin(); }
+        auto end() { return ref.rend(); }
 };
 

src/Concurrency/Keywords.cc

@@ -46 +46 @@
         }
 
+        // Only detects threads constructed with the keyword thread.
+        inline static bool isThread( DeclarationWithType * decl ) {
+                Type * baseType = decl->get_type()->stripDeclarator();
+                StructInstType * instType = dynamic_cast<StructInstType *>( baseType );
+                if ( nullptr == instType ) { return false; }
+                return instType->baseStruct->is_thread();
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -119 +127 @@
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
-                        "",
+                        "ThreadCancelled",
                         true,
                         AggregateDecl::Thread
@@ -290 +298 @@
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
                 void validate( DeclarationWithType * );
-                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
-                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
@@ -302 +311 @@
                 StructDecl* guard_decl = nullptr;
                 StructDecl* dtor_guard_decl = nullptr;
+                StructDecl* thread_guard_decl = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
@@ -801 +811 @@
                 bool first = false;
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
-                bool isDtor = CodeGen::isDestructor( decl->name );
+                bool const isDtor = CodeGen::isDestructor( decl->name );
 
                 // Is this function relevant to monitors
@@ -849 +859 @@
 
                 // Instrument the body
-                if( isDtor ) {
-                        addDtorStatments( decl, body, mutexArgs );
+                if ( isDtor && isThread( mutexArgs.front() ) ) {
+                        if( !thread_guard_decl ) {
+                                SemanticError( decl, "thread destructor requires threads to be in scope, add #include <thread.hfa>\n" );
+                        }
+                        addThreadDtorStatements( decl, body, mutexArgs );
+                }
+                else if ( isDtor ) {
+                        addDtorStatements( decl, body, mutexArgs );
                 }
                 else {
-                        addStatments( decl, body, mutexArgs );
+                        addStatements( decl, body, mutexArgs );
                 }
         }
@@ -870 +886 @@
                         assert( !dtor_guard_decl );
                         dtor_guard_decl = decl;
+                }
+                else if( decl->name == "thread_dtor_guard_t" && decl->body ) {
+                        assert( !thread_guard_decl );
+                        thread_guard_decl = decl;
                 }
         }
@@ -908 +928 @@
         }
 
-        void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+        void MutexKeyword::addDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 Type * arg_type = args.front()->get_type()->clone();
                 arg_type->set_mutex( false );
@@ -957 +977 @@
 
                 //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
-                body->push_front( new DeclStmt( monitors) );
-        }
-
-        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+                body->push_front( new DeclStmt( monitors ) );
+        }
+
+        void MutexKeyword::addThreadDtorStatements(
+                        FunctionDecl*, CompoundStmt * body,
+                        const std::list<DeclarationWithType * > & args ) {
+                assert( args.size() == 1 );
+                DeclarationWithType * arg = args.front();
+                Type * arg_type = arg->get_type()->clone();
+                assert( arg_type->get_mutex() );
+                arg_type->set_mutex( false );
+
+                // thread_dtor_guard_t __guard = { this, intptr( 0 ) };
+                body->push_front(
+                        new DeclStmt( new ObjectDecl(
+                                "__guard",
+                                noStorageClasses,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        thread_guard_decl
+                                ),
+                                new ListInit(
+                                        {
+                                                new SingleInit( new CastExpr( new VariableExpr( arg ), arg_type ) ),
+                                                new SingleInit( new UntypedExpr(
+                                                        new NameExpr( "intptr" ), {
+                                                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                                        }
+                                                ) ),
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+        }
+
+        void MutexKeyword::addStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",

src/GenPoly/GenPoly.cc

@@ -46 +46 @@
                 }
 
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, env)) return true;
+                        }
+                        return false;
+                }
+
                 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
                 bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
@@ -56 +64 @@
                 }
 
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, tyVars, env)) return true;
+                        }
+                        return false;
+                }
+
                 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
                 bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
@@ -92 +108 @@
                         Type *newType = env->lookup( typeInst->get_name() );
                         if ( newType ) return newType;
+                }
+                return type;
+        }
+
+        const ast::Type * replaceTypeInst(const ast::Type * type, const ast::TypeSubstitution * env) {
+                if (!env) return type;
+                if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
+                        auto newType = env->lookup(typeInst->name);
+                        if (newType) return newType;
                 }
                 return type;
@@ -111 +136 @@
         }
 
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+
+                if ( dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return type;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return 0;
+        }
+
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -126 +166 @@
                 }
                 return 0;
+        }
+
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+
+                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return tyVars.find(typeInst->name) != tyVars.end() ? type : nullptr;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return nullptr;
         }
 
@@ -449 +504 @@
         }
 
+        namespace {
+                // temporary hack to avoid re-implementing anything related to TyVarMap
+                // does this work? these two structs have identical definitions.
+                inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
+                        return *reinterpret_cast<const TypeDecl::Data *>(&data);
+                }
+        }
+
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
@@ -459 +522 @@
         }
 
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                ast::ptr<ast::Type> newType = arg;
+                if ( env ) env->apply( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
+
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
@@ -467 +539 @@
         }
 
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
+                const ast::FunctionType * function = getFunctionType(appExpr->func->result);
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
+                TyVarMap exprTyVars(TypeDecl::Data{});
+                makeTyVarMap(function, exprTyVars);
+                return needsBoxing(param, arg, exprTyVars, env);
+
+        }
+
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
+        }
+
+        void addToTyVarMap( const ast::TypeDecl * tyVar, TyVarMap & tyVarMap) {
+                tyVarMap.insert(tyVar->name, convData(ast::TypeDecl::Data{tyVar}));
         }
 
@@ -478 +563 @@
                 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
                         makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
+                if (auto ptype = dynamic_cast<const ast::ParameterizedType *>(type)) {
+                        for (auto & tyVar : ptype->forall) {
+                                assert (tyVar);
+                                addToTyVarMap(tyVar, tyVarMap);
+                        }
+                }
+                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
+                        makeTyVarMap(pointer->base, tyVarMap);
                 }
         }

src/GenPoly/GenPoly.h

@@ -26 +26 @@
 
 namespace GenPoly {
+
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
-
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
@@ -33 +33 @@
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env = nullptr);
 
         /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env = nullptr);
 
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
@@ -84 +86 @@
         /// true if arg requires boxing given exprTyVars
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env);
 
         /// true if arg requires boxing in the call to appExpr
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env);
 
         /// Adds the type variable `tyVar` to `tyVarMap`
@@ -93 +97 @@
         /// 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 makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap);
 
         /// Prints type variable map

src/GenPoly/Specialize.cc

@@ -218 +218 @@
                 thunkFunc->get_attributes().push_back( new Attribute( "unused" ) );
 
+                // Thunks at the global level must be static to avoid collisions between files.
+                // (Conversly thunks inside a function must be unique and not static.)
+                thunkFunc->storageClasses.is_static = !isInFunction();
+
                 // thread thunk parameters into call to actual function, naming thunk parameters as we go
                 UniqueName paramNamer( paramPrefix );

src/InitTweak/FixGlobalInit.cc

@@ -34 +34 @@
 #include "SynTree/Visitor.h"       // for acceptAll, Visitor
 
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+
 namespace InitTweak {
         class GlobalFixer : public WithShortCircuiting {
@@ -50 +54 @@
                 FunctionDecl * initFunction;
                 FunctionDecl * destroyFunction;
+        };
+
+        class GlobalFixer_new : public ast::WithShortCircuiting {
+        public:
+                void previsit (const ast::ObjectDecl *);
+                void previsit (const ast::FunctionDecl *) { visit_children = false; }
+                void previsit (const ast::StructDecl *) { visit_children = false; }
+                void previsit (const ast::UnionDecl *) { visit_children = false; }
+                void previsit (const ast::EnumDecl *) { visit_children = false; }
+                void previsit (const ast::TraitDecl *) { visit_children = false; }
+                void previsit (const ast::TypeDecl *) { visit_children = false; }
+
+                std::list< ast::ptr<ast::Stmt> > initStmts;
+                std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
 
@@ -91 +109 @@
         }
 
+        void fixGlobalInit(std::list<ast::ptr<ast::Decl>> & translationUnit, bool inLibrary) {
+                ast::Pass<GlobalFixer_new> fixer;
+                accept_all(translationUnit, fixer);
+
+                if ( !fixer.core.initStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> ctorParams;
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.initStmts)), 
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("constructor", std::move(ctorParams))});
+
+                        translationUnit.emplace_back( initFunction );
+                } // if
+
+                if ( !fixer.core.destroyStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> dtorParams;
+                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)), 
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+
+                        translationUnit.emplace_back(destroyFunction);
+                } // if
+        }
+
         void GlobalFixer::previsit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
@@ -112 +153 @@
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
-                                // Translation 1: Add this attribute on the global declaration:
-                                //    __attribute__((section (".data#")))
-                                // which makes gcc put the global in the data section,
-                                // so that the global is writeable (via a const cast) in the init function.
-                                // The trailing # is an injected assembly comment, to suppress the "a" in
-                                //    .section .data,"a"
-                                //    .section .data#,"a"
-                                // to avoid assembler warning "ignoring changed section attributes for .data"
-                                Type *strLitT = new PointerType( Type::Qualifiers( ),
-                                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
-                                std::list< Expression * > attr_params;
-                                attr_params.push_back( 
-                                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
-                                objDecl->attributes.push_back(new Attribute("section", attr_params));
-                                // Translation 2: Move the initizliation off the global declaration,
-                                // into the startup function.
+                                addDataSectonAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;
@@ -142 +168 @@
         }
 
+        void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
+                auto mutDecl = mutate(objDecl);
+                assertf(mutDecl == objDecl, "Global object decl must be unique");
+                if ( auto ctorInit = objDecl->init.as<ast::ConstructorInit>() ) {
+                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                        assert( ! ctorInit->ctor || ! ctorInit->init );
+
+                        const ast::Stmt * dtor = ctorInit->dtor;
+                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                // don't need to call intrinsic dtor, because it does nothing, but
+                                // non-intrinsic dtors must be called
+                                destroyStmts.push_front( dtor );
+                                // ctorInit->dtor = nullptr;
+                        } // if
+                        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                                initStmts.push_back( ctor );
+                                mutDecl->init = nullptr;
+                                // ctorInit->ctor = nullptr;
+                        } else if ( const ast::Init * init = ctorInit->init ) {
+                                mutDecl->init = init;
+                                // ctorInit->init = nullptr;
+                        } else {
+                                // no constructor and no initializer, which is okay
+                                mutDecl->init = nullptr;
+                        } // if
+                        // delete ctorInit;
+                } // if
+        }
+
         // only modify global variables
         void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }

src/InitTweak/FixGlobalInit.h

@@ -19 +19 @@
 #include <string>  // for string
 
+#include <AST/Fwd.hpp>
+
+
 class Declaration;
 
@@ -26 +29 @@
         /// function is for library code.
         void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fixGlobalInit( std::list< ast::ptr<ast::Decl> > & translationUnit, bool inLibrary );
 } // namespace
 

src/InitTweak/FixInit.cc

@@ -219 +219 @@
                 };
 
-                struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
+                struct SplitExpressions : public WithShortCircuiting, /*public WithTypeSubstitution, */public WithStmtsToAdd {
                         /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
                         static void split( std::list< Declaration * > &translationUnit );
@@ -802 +802 @@
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
                                         if ( objDecl->get_storageClasses().is_static ) {
+
+                                                // The ojbect needs to go in the data section, regardless of dtor complexity below.
+                                                // The attribute works, and is meant to apply, both for leaving the static local alone,
+                                                // and for hoisting it out as a static global.
+                                                addDataSectonAttribute( objDecl );
+
                                                 // originally wanted to take advantage of gcc nested functions, but
                                                 // we get memory errors with this approach. To remedy this, the static

src/InitTweak/FixInit.h

@@ -19 +19 @@
 #include <string>  // for string
 
+#include <AST/Fwd.hpp>
+
 class Declaration;
 
@@ -24 +26 @@
         /// replace constructor initializers with expression statements and unwrap basic C-style initializers
         void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
+
+        void fix( std::list<ast::ptr<ast::Decl>> & translationUnit, bool inLibrary);
 } // namespace
 

src/InitTweak/GenInit.cc

@@ -283 +283 @@
                 assert( stmts.size() <= 1 );
                 return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
+
+        }
+
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) {
+                assertf(objDecl, "genCtorDtor passed null objDecl");
+                InitExpander_new srcParam(arg);
+                return SymTab::genImplicitCall(srcParam, new ast::VariableExpr(loc, objDecl), loc, fname, objDecl);
         }
 

src/InitTweak/GenInit.h

@@ -33 +33 @@
         /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr);
 
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/InitTweak/InitTweak.cc

@@ -498 +498 @@
         }
 
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
+                assertf( func, "getParamThis: nullptr ftype" );
+                auto & params = func->params;
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( func ).c_str());
+                return params.front().strict_as<ast::ObjectDecl>();
+        }
+
         bool tryConstruct( DeclarationWithType * dwt ) {
                 ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
@@ -511 +518 @@
         }
 
+        bool tryConstruct( const ast::DeclWithType * dwt ) {
+                auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
+                return (objDecl->init == nullptr ||
+                                ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
+                        && ! objDecl->storage.is_extern
+                        && isConstructable( objDecl->type );
+        }
+
+        bool isConstructable( const ast::Type * type ) {
+                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type ) 
+                && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
+
         struct CallFinder_old {
                 CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
@@ -536 +557 @@
 
         struct CallFinder_new final {
-                std::vector< ast::ptr< ast::Expr > > matches;
+                std::vector< const ast::Expr * > matches;
                 const std::vector< std::string > names;
 
@@ -558 +579 @@
         }
 
-        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
@@ -696 +717 @@
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
-                        std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
                 }
@@ -939 +960 @@
         }
 
+        // looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
+        // following passes may accidentally resolve this expression if returned as untyped...
+        ast::Expr * createBitwiseAssignment (const ast::Expr * dst, const ast::Expr * src) {
+                static ast::ptr<ast::FunctionDecl> assign = nullptr;
+                if (!assign) {
+                        auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
+                        assign = new ast::FunctionDecl({}, "?=?", {}, 
+                        { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
+                          new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
+                        { new ast::ObjectDecl({}, "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
+                }
+                if (dst->result.as<ast::ReferenceType>()) {
+                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
+                                dst = new ast::AddressExpr(dst);
+                        }
+                }
+                else {
+                        dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
+                }
+                if (src->result.as<ast::ReferenceType>()) {
+                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
+                                src = new ast::AddressExpr(src);
+                        }
+                }
+                return new ast::ApplicationExpr(dst->location, ast::VariableExpr::functionPointer(dst->location, assign), {dst, src});
+        }
+
         struct ConstExprChecker : public WithShortCircuiting {
                 // most expressions are not const expr
@@ -1055 +1103 @@
                 return isCopyFunction( decl, "?{}" );
         }
+
+        void addDataSectonAttribute( ObjectDecl * objDecl ) {
+                Type *strLitT = new PointerType( Type::Qualifiers( ),
+                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
+                std::list< Expression * > attr_params;
+                attr_params.push_back( 
+                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
+                objDecl->attributes.push_back(new Attribute("section", attr_params));
+        }
+
 }

src/InitTweak/InitTweak.h

@@ -38 +38 @@
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getParamThis( FunctionType * ftype );
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func);
 
         /// generate a bitwise assignment operation.
         ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
+
+        ast::Expr * createBitwiseAssignment( const ast::Expr * dst, const ast::Expr * src);
 
         /// transform Initializer into an argument list that can be passed to a call expression
@@ -48 +51 @@
         /// True if the resolver should try to construct dwt
         bool tryConstruct( DeclarationWithType * dwt );
+        bool tryConstruct( const ast::DeclWithType * dwt );
 
         /// True if the type can have a user-defined constructor
         bool isConstructable( Type * t );
+        bool isConstructable( const ast::Type * t );
 
         /// True if the Initializer contains designations
@@ -79 +84 @@
         /// get all Ctor/Dtor call expressions from a Statement
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
-        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt );
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt );
 
         /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
@@ -102 +107 @@
         bool isConstExpr( Expression * expr );
         bool isConstExpr( Initializer * init );
+
+        /// Modifies objDecl to have:
+        ///    __attribute__((section (".data#")))
+        /// which makes gcc put the declared variable in the data section,
+        /// which is helpful for global constants on newer gcc versions,
+        /// so that CFA's generated initialization won't segfault when writing it via a const cast.
+        /// The trailing # is an injected assembly comment, to suppress the "a" in
+        ///    .section .data,"a"
+        ///    .section .data#,"a"
+        /// to avoid assembler warning "ignoring changed section attributes for .data"
+        void addDataSectonAttribute( ObjectDecl * objDecl );
 
         class InitExpander_old {

src/InitTweak/module.mk

@@ -23 +23 @@
         InitTweak/GenInit.h \
         InitTweak/InitTweak.cc \
-        InitTweak/InitTweak.h
+        InitTweak/InitTweak.h \
+        InitTweak/FixInitNew.cpp
 
 SRCDEMANGLE += \

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul  6 09:33:32 2020
-// Update Count     : 892
+// Last Modified On : Sat Oct 24 03:53:54 2020
+// Update Count     : 895
 //
 
@@ -205 +205 @@
 struct TypeData;
 
-class DeclarationNode : public ParseNode {
-  public:
+struct DeclarationNode : public ParseNode {
         // These enumerations must harmonize with their names in DeclarationNode.cc.
         enum BasicType { Void, Bool, Char, Int, Int128,
@@ -304 +303 @@
         bool get_inLine() const { return inLine; }
         DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
-  public:
+
         DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
 
@@ -360 +359 @@
 //##############################################################################
 
-class StatementNode final : public ParseNode {
-  public:
+struct StatementNode final : public ParseNode {
         StatementNode() { stmt = nullptr; }
         StatementNode( Statement * stmt ) : stmt( stmt ) {}
@@ -382 +380 @@
                 os << stmt.get() << std::endl;
         }
-  private:
+
         std::unique_ptr<Statement> stmt;
 }; // StatementNode
@@ -426 +424 @@
 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 );

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug  4 09:39:25 2018
-// Update Count     : 363
+// Last Modified On : Sat Oct 24 04:20:55 2020
+// Update Count     : 383
 //
 
@@ -345 +345 @@
 } // build_compound
 
+// A single statement in a control structure is always converted to a compound statement so subsequent generated code
+// can be placed within this compound statement. Otherwise, code generation has to constantly check for a single
+// 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 ) {
+        // 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
+        return first;
+} // maybe_build_compound
+
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         std::list< Expression * > out, in;

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct  9 18:09:09 2020
-// Update Count     : 4614
+// Last Modified On : Sat Oct 24 08:21:14 2020
+// Update Count     : 4624
 //
 
@@ -1080 +1080 @@
         IF '(' if_control_expression ')' statement                      %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
-                { $$ = new StatementNode( build_if( $3, $5, nullptr ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
         | IF '(' if_control_expression ')' statement ELSE statement
-                { $$ = new StatementNode( build_if( $3, $5, $7 ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
         ;
 
@@ -1130 +1130 @@
 
 case_clause:                                                                                    // CFA
-        case_label_list statement                                       { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
         ;
 
@@ -1148 +1148 @@
 iteration_statement:
         WHILE '(' push if_control_expression ')' statement pop
-                { $$ = new StatementNode( build_while( $4, $6 ) ); }
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
         | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
-                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), $4 ) ); }
+                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_do_while( $5, $2 ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
-                { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), $2 ) ); }
+                { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
         | FOR '(' push for_control_expression_list ')' statement pop
-                { $$ = new StatementNode( build_for( $4, $6 ) ); }
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
-                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
+                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
         ;
 
@@ -1341 +1341 @@
 waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
-                { $$ = build_waitfor( $2, $3, $1 ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
         | when_clause_opt waitfor statement WOR waitfor_clause
-                { $$ = build_waitfor( $2, $3, $1, $5 ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
         | when_clause_opt timeout statement                                     %prec THEN
-                { $$ = build_waitfor_timeout( $2, $3, $1 ); }
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
         | when_clause_opt ELSE statement
-                { $$ = build_waitfor_timeout( nullptr, $3, $1 ); }
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
                 // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | when_clause_opt timeout statement WOR ELSE statement
                 { 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, $3, $1, $7, $5 ); }
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
         ;
 

src/ResolvExpr/Resolver.cc

@@ -1105 +1105 @@
                 }
 
-                /// Establish post-resolver invariants for expressions
+                
+        } // anonymous namespace
+/// Establish post-resolver invariants for expressions
                 void finishExpr(
                         ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
@@ -1118 +1120 @@
                         StripCasts_new::strip( expr );
                 }
-        } // anonymous namespace
-
 
         ast::ptr< ast::Expr > resolveInVoidContext(
@@ -1139 +1139 @@
         }
 
-        namespace {
-                /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
+        /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
                 /// context.
                 ast::ptr< ast::Expr > findVoidExpression(
@@ -1151 +1150 @@
                         return newExpr;
                 }
+
+        namespace {
+                
 
                 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
@@ -1162 +1164 @@
                         CandidateRef choice =
                                 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
-                        finishExpr( choice->expr, choice->env, untyped->env );
+                        ResolvExpr::finishExpr( choice->expr, choice->env, untyped->env );
                         return std::move( choice->expr );
                 }

src/ResolvExpr/Resolver.h

@@ -66 +66 @@
         ast::ptr< ast::Expr > findSingleExpression(
                 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab );
+        ast::ptr< ast::Expr > findVoidExpression(
+                const ast::Expr * untyped, const ast::SymbolTable & symtab);
         /// Resolves a constructor init expression
         ast::ptr< ast::Init > resolveCtorInit( 

src/SymTab/Autogen.cc

@@ -233 +233 @@
         }
 
+        // 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 ) {
@@ -244 +255 @@
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
+
+        /// 
+        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));
         }
 

src/SymTab/Autogen.h

@@ -55 +55 @@
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
         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.

src/SynTree/Expression.h

@@ -163 +163 @@
 };
 
+/// VariableExpr represents an expression that simply refers to the value of a named variable.
+/// Does not take ownership of var.
+class VariableExpr : public Expression {
+  public:
+        DeclarationWithType * var;
+
+        VariableExpr();
+        VariableExpr( DeclarationWithType * var );
+        VariableExpr( const VariableExpr & other );
+        virtual ~VariableExpr();
+
+        bool get_lvalue() const final;
+
+        DeclarationWithType * get_var() const { return var; }
+        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+
+        static VariableExpr * functionPointer( FunctionDecl * decl );
+
+        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 // The following classes are used to represent expression types that cannot be converted into
 // function-call format.
@@ -329 +354 @@
 };
 
-/// VariableExpr represents an expression that simply refers to the value of a named variable.
-/// Does not take ownership of var.
-class VariableExpr : public Expression {
-  public:
-        DeclarationWithType * var;
-
-        VariableExpr();
-        VariableExpr( DeclarationWithType * var );
-        VariableExpr( const VariableExpr & other );
-        virtual ~VariableExpr();
-
-        bool get_lvalue() const final;
-
-        DeclarationWithType * get_var() const { return var; }
-        void set_var( DeclarationWithType * newValue ) { var = newValue; }
-
-        static VariableExpr * functionPointer( FunctionDecl * decl );
-
-        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-};
-
 /// ConstantExpr represents an expression that simply refers to the value of a constant
 class ConstantExpr : public Expression {

src/main.cc

@@ -343 +343 @@
                         auto transUnit = convert( move( translationUnit ) );
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                        if ( exprp ) {
+                                translationUnit = convert( move( transUnit ) );
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+
+                        PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
                         translationUnit = convert( move( transUnit ) );
                 } else {
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                        if ( exprp ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        }
+
+                        PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 }
 
-                if ( exprp ) {
-                        dump( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
-
                 // fix ObjectDecl - replaces ConstructorInit nodes
-                PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 if ( ctorinitp ) {
                         dump ( translationUnit );

tests/.expect/const-init.txt

@@ -1 @@
-done
+almost done
+dtor

tests/complex.cfa

@@ -14 +14 @@
 //
 
-#include <stdio.h>
 #include <complex.h>
 #ifdef __CFA__

tests/const-init.cfa

@@ -16 +16 @@
 /*
 
-This test shows non-crashing of generated code for constants with interesting initizers.
+These tests show non-crashing of generated code for constants with interesting initializers.
 The potential for these to crash is compiler dependent.
 
 There are two cases:
-1. static constants in one compilation unit (tested here)
+1. static constants in one compilation unit (tested here, in a few sub-cases)
 2. extern constants across compilation units (tested by libcfa being loadable, specifically
-   the constant declarations in libcfa/src/limits.cfa, which almost every test exercises,
+   the constant definitions in libcfa/src/limits.cfa, which almost every test exercises,
    including "hello;" but notably, the "limits" test does not exercise it because that test
    is compile-only)
@@ -37 +37 @@
 GCC-10 on Ubuntu 20.04    Has crashed      Has crashed
 
-For this test case to fail, with most other tests passing, would be a situation only ever
+For this test to fail, with most other tests passing, would be a situation only ever
 observed with GCC-8.
 
 */
 
+// initailized by generated function, called before main
 static const char foo = -1;
 
+struct thing{};
+void ^?{}( thing & ) { printf("dtor\n"); }
+
 int main() {
-    printf("done\n");
+    // foo is already initialized
+
+    // no dtor => stays a (static) local, initialized here
+    static const char bar = -1;
+
+    // has dtor => becomes a global, ctor called here, dtor called at exit
+    static const thing it;
+
+    printf("almost done\n");
 }

tests/exceptions/cancel/coroutine.cfa

@@ -1 +1 @@
 // Try cancelling a coroutine.
 
-#include <stdio.h>
 #include <coroutine.hfa>
 #include <exception.hfa>

tests/exceptions/conditional.cfa

@@ -5 +5 @@
 
 #include <exception.hfa>
-#include <stdio.h>
 
 VTABLE_DECLARATION(num_error)(

tests/exceptions/except-io.hfa

@@ -1 +1 @@
 // Common tools for the exception tests.
-
-#include <stdio.h>
 
 // Echo when a destructor is run and an area/block is left.

tests/exceptions/trash.cfa

@@ -2 +2 @@
 
 #include <exception.hfa>
-#include <stdio.h>
 
 TRIVIAL_EXCEPTION(yin);

tests/global-monomorph.cfa

@@ -1 @@
-// Crea
-
-#include <stdlib.hfa>
-#include <stdio.h>
+// Create monomorphic instances of polymorphic types at global scope.
 
 forall(dtype T)

tests/poly-d-cycle.cfa

@@ -1 +1 @@
 // Check that a cycle of polymorphic dtype structures can be instancated.
-
-#include <stdio.h>
 
 forall(dtype T)

tests/poly-o-cycle.cfa

@@ -1 +1 @@
 // Check that a cycle of polymorphic otype structures can be instancated.
-
-#include <stdio.h>
 
 forall(otype T)